Microsoft.DBforPostgreSQL (preview:2025-06-01)

2025/08/16 • 30 updated methods

AdministratorsMicrosoftEntra_Get (updated)
Description Gets information about a server administrator associated to a Microsoft Entra principal.
Reference Link ¶

⚶ Changes

{
  "#id": "AdministratorsMicrosoftEntra_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "principalType",
            "Enum": {
              "new": [
                [
                  "Unknown",
                  "The principal type is not known or not specified."
                ],
                [
                  "User",
                  "A Microsoft Entra user."
                ],
                [
                  "Group",
                  "A Microsoft Entra group."
                ],
                [
                  "ServicePrincipal",
                  "A Microsoft Entra service principal, typically representing an application or service identity"
                ]
              ],
              "old": [
                [
                  "Unknown",
                  ""
                ],
                [
                  "User",
                  ""
                ],
                [
                  "Group",
                  ""
                ],
                [
                  "ServicePrincipal",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/administrators/{objectId}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
objectId: string ,
}

⚐ Response (200)

{
properties:
{
principalType: enum ,
principalName: string ,
objectId: string ,
tenantId: string ,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
AdministratorsMicrosoftEntra_ListByServer (updated)
Description List all server administrators associated to a Microsoft Entra principal.
Reference Link ¶

⚶ Changes

{
  "#id": "AdministratorsMicrosoftEntra_ListByServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "#name": "principalType",
                "Enum": {
                  "new": [
                    [
                      "Unknown",
                      "The principal type is not known or not specified."
                    ],
                    [
                      "User",
                      "A Microsoft Entra user."
                    ],
                    [
                      "Group",
                      "A Microsoft Entra group."
                    ],
                    [
                      "ServicePrincipal",
                      "A Microsoft Entra service principal, typically representing an application or service identity"
                    ]
                  ],
                  "old": [
                    [
                      "Unknown",
                      ""
                    ],
                    [
                      "User",
                      ""
                    ],
                    [
                      "Group",
                      ""
                    ],
                    [
                      "ServicePrincipal",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/administrators
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
principalType: enum ,
principalName: string ,
objectId: string ,
tenantId: string ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
AdvancedThreatProtectionSettings_ListByServer (updated)
Description Lists state of advanced threat protection settings for a server.
Reference Link ¶

⚶ Changes

{
  "#id": "AdvancedThreatProtectionSettings_ListByServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Advanced threat protection is enabled."
                    ],
                    [
                      "Disabled",
                      "Advanced threat protection is disabled."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/advancedThreatProtectionSettings
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
state: enum ,
creationTime: string ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
AdvancedThreatProtectionSettings_Get (updated)
Description Gets state of advanced threat protection settings for a server.
Reference Link ¶

⚶ Changes

{
  "#id": "AdvancedThreatProtectionSettings_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "state",
            "Enum": {
              "new": [
                [
                  "Enabled",
                  "Advanced threat protection is enabled."
                ],
                [
                  "Disabled",
                  "Advanced threat protection is disabled."
                ]
              ],
              "old": [
                [
                  "Enabled",
                  ""
                ],
                [
                  "Disabled",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/advancedThreatProtectionSettings/{threatProtectionName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
threatProtectionName: string ,
}

⚐ Response (200)

{
properties:
{
state: enum ,
creationTime: string ,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
ServerThreatProtectionSettings_CreateOrUpdate (updated)
Description Creates or updates a server's Advanced Threat Protection settings.
Reference Link ¶

⚶ Changes

{
  "#id": "ServerThreatProtectionSettings_CreateOrUpdate",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "#name": "state",
            "Enum": {
              "new": [
                [
                  "Enabled",
                  "Advanced threat protection is enabled."
                ],
                [
                  "Disabled",
                  "Advanced threat protection is disabled."
                ]
              ],
              "old": [
                [
                  "Enabled",
                  ""
                ],
                [
                  "Disabled",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PUT:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/advancedThreatProtectionSettings/{threatProtectionName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
threatProtectionName: string ,
parameters:
{
properties:
{
state: enum ,
creationTime: string ,
}
,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
BackupsAutomaticAndOnDemand_Get (updated)
Description Gets information of an on demand backup, given its name.
Reference Link ¶

⚶ Changes

{
  "#id": "BackupsAutomaticAndOnDemand_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "backupType",
            "Enum": {
              "new": [
                [
                  "Full",
                  "A full backup taken automatically by the service. These backups are retained for a period of time as defined by the backup retention policy, and they cannot be deleted by the customer."
                ],
                [
                  "Customer On-Demand",
                  "A full backup triggered by the customer. These backups are retained for a period of time as defined by the backup retention policy, and they can also be deleted by the customer."
                ]
              ],
              "old": [
                [
                  "Full",
                  ""
                ],
                [
                  "Customer On-Demand",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/backups/{backupName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
backupName: string ,
}

⚐ Response (200)

{
properties:
{
backupType: enum ,
completedTime: string ,
source: string ,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
BackupsAutomaticAndOnDemand_ListByServer (updated)
Description Lists all available backups of a server.
Reference Link ¶

⚶ Changes

{
  "#id": "BackupsAutomaticAndOnDemand_ListByServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "#name": "backupType",
                "Enum": {
                  "new": [
                    [
                      "Full",
                      "A full backup taken automatically by the service. These backups are retained for a period of time as defined by the backup retention policy, and they cannot be deleted by the customer."
                    ],
                    [
                      "Customer On-Demand",
                      "A full backup triggered by the customer. These backups are retained for a period of time as defined by the backup retention policy, and they can also be deleted by the customer."
                    ]
                  ],
                  "old": [
                    [
                      "Full",
                      ""
                    ],
                    [
                      "Customer On-Demand",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/backups
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
backupType: enum ,
completedTime: string ,
source: string ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
BackupsLongTermRetention_Start (updated)
Description Initiates a long term retention backup.
Reference Link ¶

⚶ Changes

{
  "#id": "BackupsLongTermRetention_Start",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "status",
            "Enum": {
              "new": [
                [
                  "Running",
                  "The operation is currently running."
                ],
                [
                  "Cancelled",
                  "The operation was cancelled."
                ],
                [
                  "Failed",
                  "The operation failed."
                ],
                [
                  "Succeeded",
                  "The operation succeeded."
                ]
              ],
              "old": [
                [
                  "Running",
                  ""
                ],
                [
                  "Cancelled",
                  ""
                ],
                [
                  "Failed",
                  ""
                ],
                [
                  "Succeeded",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

POST:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/startLtrBackup
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
parameters:
{
targetDetails:
{
sasUriList:
[
string ,
]
,
}
,
}
,
}

⚐ Response (200)

{
$headers:
{
x-ms-request-id: string ,
}
,
$schema:
{
properties:
{
datasourceSizeInBytes: integer ,
dataTransferredInBytes: integer ,
backupName: string ,
backupMetadata: string ,
status: enum ,
startTime: string ,
endTime: string ,
percentComplete: number ,
errorCode: string ,
errorMessage: string ,
}
,
}
,
}

⚐ Response (202)

{
retry-after: integer ,
x-ms-request-id: string ,
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
$headers:
{
x-ms-error-code: string ,
x-ms-request-id: string ,
}
,
$schema:
{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
,
}
BackupsLongTermRetention_Get (updated)
Description Gets the results of a long retention backup operation for a server.
Reference Link ¶

⚶ Changes

{
  "#id": "BackupsLongTermRetention_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "status",
            "Enum": {
              "new": [
                [
                  "Running",
                  "The operation is currently running."
                ],
                [
                  "Cancelled",
                  "The operation was cancelled."
                ],
                [
                  "Failed",
                  "The operation failed."
                ],
                [
                  "Succeeded",
                  "The operation succeeded."
                ]
              ],
              "old": [
                [
                  "Running",
                  ""
                ],
                [
                  "Cancelled",
                  ""
                ],
                [
                  "Failed",
                  ""
                ],
                [
                  "Succeeded",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/ltrBackupOperations/{backupName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
backupName: string ,
}

⚐ Response (200)

{
properties:
{
datasourceSizeInBytes: integer ,
dataTransferredInBytes: integer ,
backupName: string ,
backupMetadata: string ,
status: enum ,
startTime: string ,
endTime: string ,
percentComplete: number ,
errorCode: string ,
errorMessage: string ,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
BackupsLongTermRetention_ListByServer (updated)
Description Lists the results of the long term retention backup operations for a server.
Reference Link ¶

⚶ Changes

{
  "#id": "BackupsLongTermRetention_ListByServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "#name": "status",
                "Enum": {
                  "new": [
                    [
                      "Running",
                      "The operation is currently running."
                    ],
                    [
                      "Cancelled",
                      "The operation was cancelled."
                    ],
                    [
                      "Failed",
                      "The operation failed."
                    ],
                    [
                      "Succeeded",
                      "The operation succeeded."
                    ]
                  ],
                  "old": [
                    [
                      "Running",
                      ""
                    ],
                    [
                      "Cancelled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/ltrBackupOperations
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
datasourceSizeInBytes: integer ,
dataTransferredInBytes: integer ,
backupName: string ,
backupMetadata: string ,
status: enum ,
startTime: string ,
endTime: string ,
percentComplete: number ,
errorCode: string ,
errorMessage: string ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
CapabilitiesByLocation_List (updated)
Description Lists the capabilities available in a given location for a specific subscription.
Reference Link ¶

⚶ Changes

{
  "#id": "CapabilitiesByLocation_List",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": [
            {
              "supportedServerEditions": {
                "$properties": {
                  "supportedServerSkus": {
                    "$properties": {
                      "supportedHaMode": {
                        "Enum": {
                          "new": [
                            [
                              "SameZone",
                              "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                            ],
                            [
                              "ZoneRedundant",
                              "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                            ]
                          ],
                          "old": [
                            [
                              "SameZone",
                              ""
                            ],
                            [
                              "ZoneRedundant",
                              ""
                            ]
                          ]
                        }
                      },
                      "supportedFeatures": {
                        "$properties": [
                          {
                            "#name": "status",
                            "Enum": {
                              "new": [
                                [
                                  "Enabled",
                                  "Feature is enabled."
                                ],
                                [
                                  "Disabled",
                                  "Feature is disabled."
                                ]
                              ],
                              "old": [
                                [
                                  "Enabled",
                                  ""
                                ],
                                [
                                  "Disabled",
                                  ""
                                ]
                              ]
                            }
                          }
                        ]
                      }
                    }
                  }
                }
              }
            },
            {
              "supportedServerVersions": {
                "$properties": {
                  "supportedFeatures": {
                    "$properties": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Enabled",
                              "Feature is enabled."
                            ],
                            [
                              "Disabled",
                              "Feature is disabled."
                            ]
                          ],
                          "old": [
                            [
                              "Enabled",
                              ""
                            ],
                            [
                              "Disabled",
                              ""
                            ]
                          ]
                        }
                      }
                    ]
                  }
                }
              }
            },
            {
              "supportedFeatures": {
                "$properties": [
                  {
                    "#name": "status",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Feature is enabled."
                        ],
                        [
                          "Disabled",
                          "Feature is disabled."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              }
            },
            {
              "#name": "fastProvisioningSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Fast provisioning is supported."
                  ],
                  [
                    "Disabled",
                    "Fast provisioning is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "geoBackupSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Geographically redundant backups are supported."
                  ],
                  [
                    "Disabled",
                    "Geographically redundant backups are not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "zoneRedundantHaSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "High availability with zone redundancy is supported."
                  ],
                  [
                    "Disabled",
                    "High availability with zone redundancy is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "zoneRedundantHaAndGeoBackupSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "High availability with zone redundancy is supported in conjunction with geographically redundant backups."
                  ],
                  [
                    "Disabled",
                    "High availability with zone redundancy is not supported in conjunction with geographically redundant backups."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "storageAutoGrowthSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Storage autogrow is supported."
                  ],
                  [
                    "Disabled",
                    "Storage autogrow is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "onlineResizeSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Resizing the storage without interrupting the operation of the database engine is supported."
                  ],
                  [
                    "Disabled",
                    "Resizing the storage without interrupting the operation of the database engine is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "restricted",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Location is restricted."
                  ],
                  [
                    "Disabled",
                    "Location is not restricted."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            }
          ]
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/providers/Microsoft.DBforPostgreSQL/locations/{locationName}/capabilities
{
api-version: string ,
subscriptionId: string ,
locationName: string ,
}

⚐ Response (200)

{
value:
[
{
name: string ,
supportedServerEditions:
[
{
name: string ,
defaultSkuName: string ,
supportedStorageEditions:
[
{
name: string ,
defaultStorageSizeMb: integer ,
supportedStorageMb:
[
{
supportedIops: integer ,
supportedMaximumIops: integer ,
storageSizeMb: integer ,
maximumStorageSizeMb: integer ,
supportedThroughput: integer ,
supportedMaximumThroughput: integer ,
defaultIopsTier: string ,
supportedIopsTiers:
[
{
name: string ,
iops: integer ,
}
,
]
,
}
,
]
,
}
,
]
,
supportedServerSkus:
[
{
name: string ,
vCores: integer ,
supportedIops: integer ,
supportedMemoryPerVcoreMb: integer ,
supportedZones:
[
string ,
]
,
supportedHaMode:
[
string ,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
securityProfile: string ,
}
,
]
,
}
,
]
,
supportedServerVersions:
[
{
name: string ,
supportedVersionsToUpgrade:
[
string ,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
}
,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
fastProvisioningSupported: enum ,
supportedFastProvisioningEditions:
[
{
supportedTier: string ,
supportedSku: string ,
supportedStorageGb: integer ,
supportedServerVersions: string ,
serverCount: integer ,
}
,
]
,
geoBackupSupported: enum ,
zoneRedundantHaSupported: enum ,
zoneRedundantHaAndGeoBackupSupported: enum ,
storageAutoGrowthSupported: enum ,
onlineResizeSupported: enum ,
restricted: enum ,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
CapabilitiesByServer_List (updated)
Description Lists the capabilities available for a given server.
Reference Link ¶

⚶ Changes

{
  "#id": "CapabilitiesByServer_List",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": [
            {
              "supportedServerEditions": {
                "$properties": {
                  "supportedServerSkus": {
                    "$properties": {
                      "supportedHaMode": {
                        "Enum": {
                          "new": [
                            [
                              "SameZone",
                              "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                            ],
                            [
                              "ZoneRedundant",
                              "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                            ]
                          ],
                          "old": [
                            [
                              "SameZone",
                              ""
                            ],
                            [
                              "ZoneRedundant",
                              ""
                            ]
                          ]
                        }
                      },
                      "supportedFeatures": {
                        "$properties": [
                          {
                            "#name": "status",
                            "Enum": {
                              "new": [
                                [
                                  "Enabled",
                                  "Feature is enabled."
                                ],
                                [
                                  "Disabled",
                                  "Feature is disabled."
                                ]
                              ],
                              "old": [
                                [
                                  "Enabled",
                                  ""
                                ],
                                [
                                  "Disabled",
                                  ""
                                ]
                              ]
                            }
                          }
                        ]
                      }
                    }
                  }
                }
              }
            },
            {
              "supportedServerVersions": {
                "$properties": {
                  "supportedFeatures": {
                    "$properties": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Enabled",
                              "Feature is enabled."
                            ],
                            [
                              "Disabled",
                              "Feature is disabled."
                            ]
                          ],
                          "old": [
                            [
                              "Enabled",
                              ""
                            ],
                            [
                              "Disabled",
                              ""
                            ]
                          ]
                        }
                      }
                    ]
                  }
                }
              }
            },
            {
              "supportedFeatures": {
                "$properties": [
                  {
                    "#name": "status",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Feature is enabled."
                        ],
                        [
                          "Disabled",
                          "Feature is disabled."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              }
            },
            {
              "#name": "fastProvisioningSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Fast provisioning is supported."
                  ],
                  [
                    "Disabled",
                    "Fast provisioning is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "geoBackupSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Geographically redundant backups are supported."
                  ],
                  [
                    "Disabled",
                    "Geographically redundant backups are not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "zoneRedundantHaSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "High availability with zone redundancy is supported."
                  ],
                  [
                    "Disabled",
                    "High availability with zone redundancy is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "zoneRedundantHaAndGeoBackupSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "High availability with zone redundancy is supported in conjunction with geographically redundant backups."
                  ],
                  [
                    "Disabled",
                    "High availability with zone redundancy is not supported in conjunction with geographically redundant backups."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "storageAutoGrowthSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Storage autogrow is supported."
                  ],
                  [
                    "Disabled",
                    "Storage autogrow is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "onlineResizeSupported",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Resizing the storage without interrupting the operation of the database engine is supported."
                  ],
                  [
                    "Disabled",
                    "Resizing the storage without interrupting the operation of the database engine is not supported."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            },
            {
              "#name": "restricted",
              "Enum": {
                "new": [
                  [
                    "Enabled",
                    "Location is restricted."
                  ],
                  [
                    "Disabled",
                    "Location is not restricted."
                  ]
                ],
                "old": [
                  [
                    "Enabled",
                    ""
                  ],
                  [
                    "Disabled",
                    ""
                  ]
                ]
              }
            }
          ]
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/capabilities
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
name: string ,
supportedServerEditions:
[
{
name: string ,
defaultSkuName: string ,
supportedStorageEditions:
[
{
name: string ,
defaultStorageSizeMb: integer ,
supportedStorageMb:
[
{
supportedIops: integer ,
supportedMaximumIops: integer ,
storageSizeMb: integer ,
maximumStorageSizeMb: integer ,
supportedThroughput: integer ,
supportedMaximumThroughput: integer ,
defaultIopsTier: string ,
supportedIopsTiers:
[
{
name: string ,
iops: integer ,
}
,
]
,
}
,
]
,
}
,
]
,
supportedServerSkus:
[
{
name: string ,
vCores: integer ,
supportedIops: integer ,
supportedMemoryPerVcoreMb: integer ,
supportedZones:
[
string ,
]
,
supportedHaMode:
[
string ,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
securityProfile: string ,
}
,
]
,
}
,
]
,
supportedServerVersions:
[
{
name: string ,
supportedVersionsToUpgrade:
[
string ,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
}
,
]
,
supportedFeatures:
[
{
name: string ,
status: enum ,
}
,
]
,
fastProvisioningSupported: enum ,
supportedFastProvisioningEditions:
[
{
supportedTier: string ,
supportedSku: string ,
supportedStorageGb: integer ,
supportedServerVersions: string ,
serverCount: integer ,
}
,
]
,
geoBackupSupported: enum ,
zoneRedundantHaSupported: enum ,
zoneRedundantHaAndGeoBackupSupported: enum ,
storageAutoGrowthSupported: enum ,
onlineResizeSupported: enum ,
restricted: enum ,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Configurations_ListByServer (updated)
Description Lists all configurations (also known as server parameters) of a server.
Reference Link ¶

⚶ Changes

{
  "#id": "Configurations_ListByServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "#name": "dataType",
                "Enum": {
                  "new": [
                    [
                      "Boolean",
                      "A boolean value."
                    ],
                    [
                      "Numeric",
                      "A numeric value."
                    ],
                    [
                      "Integer",
                      "An integer value."
                    ],
                    [
                      "Enumeration",
                      "An enumeration value."
                    ],
                    [
                      "String",
                      "A string value."
                    ],
                    [
                      "Set",
                      "A set of values."
                    ]
                  ],
                  "old": [
                    [
                      "Boolean",
                      ""
                    ],
                    [
                      "Numeric",
                      ""
                    ],
                    [
                      "Integer",
                      ""
                    ],
                    [
                      "Enumeration",
                      ""
                    ],
                    [
                      "String",
                      ""
                    ],
                    [
                      "Set",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/configurations
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
value: string ,
description: string ,
defaultValue: string ,
dataType: enum ,
allowedValues: string ,
source: string ,
isDynamicConfig: boolean ,
isReadOnly: boolean ,
isConfigPendingRestart: boolean ,
unit: string ,
documentationLink: string ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Configurations_Get (updated)
Description Gets information about a specific configuration (also known as server parameter) of a server.
Reference Link ¶

⚶ Changes

{
  "#id": "Configurations_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "#name": "dataType",
            "Enum": {
              "new": [
                [
                  "Boolean",
                  "A boolean value."
                ],
                [
                  "Numeric",
                  "A numeric value."
                ],
                [
                  "Integer",
                  "An integer value."
                ],
                [
                  "Enumeration",
                  "An enumeration value."
                ],
                [
                  "String",
                  "A string value."
                ],
                [
                  "Set",
                  "A set of values."
                ]
              ],
              "old": [
                [
                  "Boolean",
                  ""
                ],
                [
                  "Numeric",
                  ""
                ],
                [
                  "Integer",
                  ""
                ],
                [
                  "Enumeration",
                  ""
                ],
                [
                  "String",
                  ""
                ],
                [
                  "Set",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/configurations/{configurationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
configurationName: string ,
}

⚐ Response (200)

{
properties:
{
value: string ,
description: string ,
defaultValue: string ,
dataType: enum ,
allowedValues: string ,
source: string ,
isDynamicConfig: boolean ,
isReadOnly: boolean ,
isConfigPendingRestart: boolean ,
unit: string ,
documentationLink: string ,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Configurations_Update (updated)
Description Updates the value assigned to a specific modifiable configuration (also known as server parameter) of a server.
Reference Link ¶

⚶ Changes

{
  "#id": "Configurations_Update",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "#name": "dataType",
            "Enum": {
              "new": [
                [
                  "Boolean",
                  "A boolean value."
                ],
                [
                  "Numeric",
                  "A numeric value."
                ],
                [
                  "Integer",
                  "An integer value."
                ],
                [
                  "Enumeration",
                  "An enumeration value."
                ],
                [
                  "String",
                  "A string value."
                ],
                [
                  "Set",
                  "A set of values."
                ]
              ],
              "old": [
                [
                  "Boolean",
                  ""
                ],
                [
                  "Numeric",
                  ""
                ],
                [
                  "Integer",
                  ""
                ],
                [
                  "Enumeration",
                  ""
                ],
                [
                  "String",
                  ""
                ],
                [
                  "Set",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PATCH:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/configurations/{configurationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
configurationName: string ,
parameters:
{
properties:
{
value: string ,
description: string ,
defaultValue: string ,
dataType: enum ,
allowedValues: string ,
source: string ,
isDynamicConfig: boolean ,
isReadOnly: boolean ,
isConfigPendingRestart: boolean ,
unit: string ,
documentationLink: string ,
}
,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Configurations_Put (updated)
Description Updates, using Put verb, the value assigned to a specific modifiable configuration (also known as server parameter) of a server.
Reference Link ¶

⚶ Changes

{
  "#id": "Configurations_Put",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "#name": "dataType",
            "Enum": {
              "new": [
                [
                  "Boolean",
                  "A boolean value."
                ],
                [
                  "Numeric",
                  "A numeric value."
                ],
                [
                  "Integer",
                  "An integer value."
                ],
                [
                  "Enumeration",
                  "An enumeration value."
                ],
                [
                  "String",
                  "A string value."
                ],
                [
                  "Set",
                  "A set of values."
                ]
              ],
              "old": [
                [
                  "Boolean",
                  ""
                ],
                [
                  "Numeric",
                  ""
                ],
                [
                  "Integer",
                  ""
                ],
                [
                  "Enumeration",
                  ""
                ],
                [
                  "String",
                  ""
                ],
                [
                  "Set",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PUT:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/configurations/{configurationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
configurationName: string ,
parameters:
{
properties:
{
value: string ,
description: string ,
defaultValue: string ,
dataType: enum ,
allowedValues: string ,
source: string ,
isDynamicConfig: boolean ,
isReadOnly: boolean ,
isConfigPendingRestart: boolean ,
unit: string ,
documentationLink: string ,
}
,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_Create (updated)
Description Creates a new migration.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_Create",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  },
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    },
    "201": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PUT:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/migrations/{migrationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
migrationName: string ,
parameters:
{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}
,
}

⚐ Response (200)

{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}

⚐ Response (201)

{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_Get (updated)
Description Gets information about a migration.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/migrations/{migrationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
migrationName: string ,
}

⚐ Response (200)

{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_Update (updated)
Description Updates an existing migration. The request body can contain one to many of the mutable properties present in the migration definition. Certain property updates initiate migration state transitions.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_Update",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  },
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PATCH:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/migrations/{migrationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
migrationName: string ,
parameters:
{
properties:
{
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
migrationMode: enum ,
}
,
tags: object ,
}
,
}

⚐ Response (200)

{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_Cancel (updated)
Description Cancels an active migration.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_Cancel",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "currentStatus": [
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "InProgress",
                      "Migration is in progress."
                    ],
                    [
                      "WaitingForUserAction",
                      "Migration is waiting for user action."
                    ],
                    [
                      "Canceled",
                      "Migration has been canceled."
                    ],
                    [
                      "Failed",
                      "Migration has failed."
                    ],
                    [
                      "Succeeded",
                      "Migration has succeeded."
                    ],
                    [
                      "ValidationFailed",
                      "Validation for migration has failed."
                    ],
                    [
                      "CleaningUp",
                      "Migration is cleaning up resources."
                    ]
                  ],
                  "old": [
                    [
                      "InProgress",
                      ""
                    ],
                    [
                      "WaitingForUserAction",
                      ""
                    ],
                    [
                      "Canceled",
                      ""
                    ],
                    [
                      "Failed",
                      ""
                    ],
                    [
                      "Succeeded",
                      ""
                    ],
                    [
                      "ValidationFailed",
                      ""
                    ],
                    [
                      "CleaningUp",
                      ""
                    ]
                  ]
                }
              },
              {
                "currentSubStateDetails": [
                  {
                    "#name": "currentSubState",
                    "Enum": {
                      "new": [
                        [
                          "PerformingPreRequisiteSteps",
                          "Performing pre-requisite steps for migration."
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          "Waiting for logical replication setup request on source database."
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          "Waiting for databases to migrate specification."
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          "Waiting for target database overwrite confirmation."
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          "Waiting for data migration scheduling."
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          "Waiting for data migration window."
                        ],
                        [
                          "MigratingData",
                          "Migrating data."
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          "Waiting for cutover trigger."
                        ],
                        [
                          "CompletingMigration",
                          "Completing migration."
                        ],
                        [
                          "Completed",
                          "Migration completed."
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          "Canceling requested database migrations."
                        ],
                        [
                          "ValidationInProgress",
                          "Validation in progress."
                        ]
                      ],
                      "old": [
                        [
                          "PerformingPreRequisiteSteps",
                          ""
                        ],
                        [
                          "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                          ""
                        ],
                        [
                          "WaitingForDBsToMigrateSpecification",
                          ""
                        ],
                        [
                          "WaitingForTargetDBOverwriteConfirmation",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationScheduling",
                          ""
                        ],
                        [
                          "WaitingForDataMigrationWindow",
                          ""
                        ],
                        [
                          "MigratingData",
                          ""
                        ],
                        [
                          "WaitingForCutoverTrigger",
                          ""
                        ],
                        [
                          "CompletingMigration",
                          ""
                        ],
                        [
                          "Completed",
                          ""
                        ],
                        [
                          "CancelingRequestedDBMigrations",
                          ""
                        ],
                        [
                          "ValidationInProgress",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "validationDetails": [
                      {
                        "#name": "status",
                        "Enum": {
                          "new": [
                            [
                              "Failed",
                              "Validation has failed."
                            ],
                            [
                              "Succeeded",
                              "Validation has succeeded."
                            ],
                            [
                              "Warning",
                              "Validation has succeeded with warnings."
                            ]
                          ],
                          "old": [
                            [
                              "Failed",
                              ""
                            ],
                            [
                              "Succeeded",
                              ""
                            ],
                            [
                              "Warning",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "serverLevelValidationDetails": {
                          "$properties": [
                            {
                              "#name": "state",
                              "Enum": {
                                "new": [
                                  [
                                    "Failed",
                                    "Validation has failed."
                                  ],
                                  [
                                    "Succeeded",
                                    "Validation has succeeded."
                                  ],
                                  [
                                    "Warning",
                                    "Validation has succeeded with warnings."
                                  ]
                                ],
                                "old": [
                                  [
                                    "Failed",
                                    ""
                                  ],
                                  [
                                    "Succeeded",
                                    ""
                                  ],
                                  [
                                    "Warning",
                                    ""
                                  ]
                                ]
                              }
                            },
                            {
                              "messages": {
                                "$properties": [
                                  {
                                    "#name": "state",
                                    "Enum": {
                                      "new": [
                                        [
                                          "Failed",
                                          "Validation has failed."
                                        ],
                                        [
                                          "Succeeded",
                                          "Validation has succeeded."
                                        ],
                                        [
                                          "Warning",
                                          "Validation has succeeded with warnings."
                                        ]
                                      ],
                                      "old": [
                                        [
                                          "Failed",
                                          ""
                                        ],
                                        [
                                          "Succeeded",
                                          ""
                                        ],
                                        [
                                          "Warning",
                                          ""
                                        ]
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      },
                      {
                        "dbLevelValidationDetails": {
                          "$properties": {
                            "summary": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          }
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "#name": "migrationMode",
            "Enum": {
              "new": [
                [
                  "Offline",
                  "Offline migration mode."
                ],
                [
                  "Online",
                  "Online migration mode."
                ]
              ],
              "old": [
                [
                  "Offline",
                  ""
                ],
                [
                  "Online",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrationOption",
            "Enum": {
              "new": [
                [
                  "Validate",
                  "Validate the migration without performing it."
                ],
                [
                  "Migrate",
                  "Perform the migration."
                ],
                [
                  "ValidateAndMigrate",
                  "Validate and perform the migration."
                ]
              ],
              "old": [
                [
                  "Validate",
                  ""
                ],
                [
                  "Migrate",
                  ""
                ],
                [
                  "ValidateAndMigrate",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sourceType",
            "Enum": {
              "new": [
                [
                  "OnPremises",
                  "On-premises PostgreSQL server."
                ],
                [
                  "AWS",
                  "Amazon Web Services PostgreSQL server."
                ],
                [
                  "GCP",
                  "Google Cloud Platform PostgreSQL server."
                ],
                [
                  "AzureVM",
                  "Azure Virtual Machine PostgreSQL server."
                ],
                [
                  "PostgreSQLSingleServer",
                  "Azure Database for PostgreSQL single server."
                ],
                [
                  "AWS_RDS",
                  "Amazon RDS for PostgreSQL."
                ],
                [
                  "AWS_AURORA",
                  "Amazon Aurora for PostgreSQL."
                ],
                [
                  "AWS_EC2",
                  "Amazon EC2 for PostgreSQL."
                ],
                [
                  "GCP_CloudSQL",
                  "Google Cloud SQL for PostgreSQL."
                ],
                [
                  "GCP_AlloyDB",
                  "Google Cloud AlloyDB for PostgreSQL."
                ],
                [
                  "GCP_Compute",
                  "Google Compute Engine for PostgreSQL."
                ],
                [
                  "EDB",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "EDB_Oracle_Server",
                  "EnterpriseDB Oracle Server."
                ],
                [
                  "EDB_PostgreSQL",
                  "EnterpriseDB PostgreSQL server."
                ],
                [
                  "PostgreSQLFlexibleServer",
                  "Azure Database for PostgreSQL flexible server."
                ],
                [
                  "PostgreSQLCosmosDB",
                  ".NET Cosmos DB for PostgreSQL"
                ],
                [
                  "Huawei_RDS",
                  "Huawei RDS for PostgreSQL"
                ],
                [
                  "Huawei_Compute",
                  "Huawei Compute for PostgreSQL"
                ],
                [
                  "Heroku_PostgreSQL",
                  "Heroku PostgreSQL"
                ],
                [
                  "Crunchy_PostgreSQL",
                  "Crunchy PostgreSQL"
                ],
                [
                  "ApsaraDB_RDS",
                  "ApsaraDB RDS for PostgreSQL"
                ],
                [
                  "Digital_Ocean_Droplets",
                  "Digital Ocean Droplets for PostgreSQL"
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  "Digital Ocean PostgreSQL"
                ],
                [
                  "Supabase_PostgreSQL",
                  "Supabase PostgreSQL"
                ]
              ],
              "old": [
                [
                  "OnPremises",
                  ""
                ],
                [
                  "AWS",
                  ""
                ],
                [
                  "GCP",
                  ""
                ],
                [
                  "AzureVM",
                  ""
                ],
                [
                  "PostgreSQLSingleServer",
                  ""
                ],
                [
                  "AWS_RDS",
                  ""
                ],
                [
                  "AWS_AURORA",
                  ""
                ],
                [
                  "AWS_EC2",
                  ""
                ],
                [
                  "GCP_CloudSQL",
                  ""
                ],
                [
                  "GCP_AlloyDB",
                  ""
                ],
                [
                  "GCP_Compute",
                  ""
                ],
                [
                  "EDB",
                  ""
                ],
                [
                  "EDB_Oracle_Server",
                  ""
                ],
                [
                  "EDB_PostgreSQL",
                  ""
                ],
                [
                  "PostgreSQLFlexibleServer",
                  ""
                ],
                [
                  "PostgreSQLCosmosDB",
                  ""
                ],
                [
                  "Huawei_RDS",
                  ""
                ],
                [
                  "Huawei_Compute",
                  ""
                ],
                [
                  "Heroku_PostgreSQL",
                  ""
                ],
                [
                  "Crunchy_PostgreSQL",
                  ""
                ],
                [
                  "ApsaraDB_RDS",
                  ""
                ],
                [
                  "Digital_Ocean_Droplets",
                  ""
                ],
                [
                  "Digital_Ocean_PostgreSQL",
                  ""
                ],
                [
                  "Supabase_PostgreSQL",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "sslMode",
            "Enum": {
              "new": [
                [
                  "Prefer",
                  "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                ],
                [
                  "Require",
                  "Require SSL connection. If the server does not support SSL, the connection will fail."
                ],
                [
                  "VerifyCA",
                  "Require SSL connection and verify the server certificate against the CA certificate."
                ],
                [
                  "VerifyFull",
                  "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                ]
              ],
              "old": [
                [
                  "Prefer",
                  ""
                ],
                [
                  "Require",
                  ""
                ],
                [
                  "VerifyCA",
                  ""
                ],
                [
                  "VerifyFull",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
            "Enum": {
              "new": [
                [
                  "True",
                  "Logical replication will be set up on the source server."
                ],
                [
                  "False",
                  "Logical replication will not be set up on the source server."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "overwriteDbsInTarget",
            "Enum": {
              "new": [
                [
                  "True",
                  "Databases on the target server can be overwritten when already present."
                ],
                [
                  "False",
                  "Databases on the target server cannot be overwritten when already present."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "migrateRoles",
            "Enum": {
              "new": [
                [
                  "True",
                  "Roles and permissions will be migrated."
                ],
                [
                  "False",
                  "Roles and permissions will not be migrated."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "startDataMigration",
            "Enum": {
              "new": [
                [
                  "True",
                  "Data migration must start right away."
                ],
                [
                  "False",
                  "Data migration must not start right away."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "triggerCutover",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cutover must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cutover must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "cancel",
            "Enum": {
              "new": [
                [
                  "True",
                  "Cancel must be triggered for the entire migration."
                ],
                [
                  "False",
                  "Cancel must not be triggered for the entire migration."
                ]
              ],
              "old": [
                [
                  "True",
                  ""
                ],
                [
                  "False",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

DELETE:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/migrations/{migrationName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
migrationName: string ,
}

⚐ Response (200)

{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}

⚐ Response (204)

{}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_ListByTargetServer (updated)
Description Lists all migrations of a target flexible server.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_ListByTargetServer",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "currentStatus": [
                  {
                    "#name": "state",
                    "Enum": {
                      "new": [
                        [
                          "InProgress",
                          "Migration is in progress."
                        ],
                        [
                          "WaitingForUserAction",
                          "Migration is waiting for user action."
                        ],
                        [
                          "Canceled",
                          "Migration has been canceled."
                        ],
                        [
                          "Failed",
                          "Migration has failed."
                        ],
                        [
                          "Succeeded",
                          "Migration has succeeded."
                        ],
                        [
                          "ValidationFailed",
                          "Validation for migration has failed."
                        ],
                        [
                          "CleaningUp",
                          "Migration is cleaning up resources."
                        ]
                      ],
                      "old": [
                        [
                          "InProgress",
                          ""
                        ],
                        [
                          "WaitingForUserAction",
                          ""
                        ],
                        [
                          "Canceled",
                          ""
                        ],
                        [
                          "Failed",
                          ""
                        ],
                        [
                          "Succeeded",
                          ""
                        ],
                        [
                          "ValidationFailed",
                          ""
                        ],
                        [
                          "CleaningUp",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "currentSubStateDetails": [
                      {
                        "#name": "currentSubState",
                        "Enum": {
                          "new": [
                            [
                              "PerformingPreRequisiteSteps",
                              "Performing pre-requisite steps for migration."
                            ],
                            [
                              "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                              "Waiting for logical replication setup request on source database."
                            ],
                            [
                              "WaitingForDBsToMigrateSpecification",
                              "Waiting for databases to migrate specification."
                            ],
                            [
                              "WaitingForTargetDBOverwriteConfirmation",
                              "Waiting for target database overwrite confirmation."
                            ],
                            [
                              "WaitingForDataMigrationScheduling",
                              "Waiting for data migration scheduling."
                            ],
                            [
                              "WaitingForDataMigrationWindow",
                              "Waiting for data migration window."
                            ],
                            [
                              "MigratingData",
                              "Migrating data."
                            ],
                            [
                              "WaitingForCutoverTrigger",
                              "Waiting for cutover trigger."
                            ],
                            [
                              "CompletingMigration",
                              "Completing migration."
                            ],
                            [
                              "Completed",
                              "Migration completed."
                            ],
                            [
                              "CancelingRequestedDBMigrations",
                              "Canceling requested database migrations."
                            ],
                            [
                              "ValidationInProgress",
                              "Validation in progress."
                            ]
                          ],
                          "old": [
                            [
                              "PerformingPreRequisiteSteps",
                              ""
                            ],
                            [
                              "WaitingForLogicalReplicationSetupRequestOnSourceDB",
                              ""
                            ],
                            [
                              "WaitingForDBsToMigrateSpecification",
                              ""
                            ],
                            [
                              "WaitingForTargetDBOverwriteConfirmation",
                              ""
                            ],
                            [
                              "WaitingForDataMigrationScheduling",
                              ""
                            ],
                            [
                              "WaitingForDataMigrationWindow",
                              ""
                            ],
                            [
                              "MigratingData",
                              ""
                            ],
                            [
                              "WaitingForCutoverTrigger",
                              ""
                            ],
                            [
                              "CompletingMigration",
                              ""
                            ],
                            [
                              "Completed",
                              ""
                            ],
                            [
                              "CancelingRequestedDBMigrations",
                              ""
                            ],
                            [
                              "ValidationInProgress",
                              ""
                            ]
                          ]
                        }
                      },
                      {
                        "validationDetails": [
                          {
                            "#name": "status",
                            "Enum": {
                              "new": [
                                [
                                  "Failed",
                                  "Validation has failed."
                                ],
                                [
                                  "Succeeded",
                                  "Validation has succeeded."
                                ],
                                [
                                  "Warning",
                                  "Validation has succeeded with warnings."
                                ]
                              ],
                              "old": [
                                [
                                  "Failed",
                                  ""
                                ],
                                [
                                  "Succeeded",
                                  ""
                                ],
                                [
                                  "Warning",
                                  ""
                                ]
                              ]
                            }
                          },
                          {
                            "serverLevelValidationDetails": {
                              "$properties": [
                                {
                                  "#name": "state",
                                  "Enum": {
                                    "new": [
                                      [
                                        "Failed",
                                        "Validation has failed."
                                      ],
                                      [
                                        "Succeeded",
                                        "Validation has succeeded."
                                      ],
                                      [
                                        "Warning",
                                        "Validation has succeeded with warnings."
                                      ]
                                    ],
                                    "old": [
                                      [
                                        "Failed",
                                        ""
                                      ],
                                      [
                                        "Succeeded",
                                        ""
                                      ],
                                      [
                                        "Warning",
                                        ""
                                      ]
                                    ]
                                  }
                                },
                                {
                                  "messages": {
                                    "$properties": [
                                      {
                                        "#name": "state",
                                        "Enum": {
                                          "new": [
                                            [
                                              "Failed",
                                              "Validation has failed."
                                            ],
                                            [
                                              "Succeeded",
                                              "Validation has succeeded."
                                            ],
                                            [
                                              "Warning",
                                              "Validation has succeeded with warnings."
                                            ]
                                          ],
                                          "old": [
                                            [
                                              "Failed",
                                              ""
                                            ],
                                            [
                                              "Succeeded",
                                              ""
                                            ],
                                            [
                                              "Warning",
                                              ""
                                            ]
                                          ]
                                        }
                                      }
                                    ]
                                  }
                                }
                              ]
                            }
                          },
                          {
                            "dbLevelValidationDetails": {
                              "$properties": {
                                "summary": {
                                  "$properties": [
                                    {
                                      "#name": "state",
                                      "Enum": {
                                        "new": [
                                          [
                                            "Failed",
                                            "Validation has failed."
                                          ],
                                          [
                                            "Succeeded",
                                            "Validation has succeeded."
                                          ],
                                          [
                                            "Warning",
                                            "Validation has succeeded with warnings."
                                          ]
                                        ],
                                        "old": [
                                          [
                                            "Failed",
                                            ""
                                          ],
                                          [
                                            "Succeeded",
                                            ""
                                          ],
                                          [
                                            "Warning",
                                            ""
                                          ]
                                        ]
                                      }
                                    },
                                    {
                                      "messages": {
                                        "$properties": [
                                          {
                                            "#name": "state",
                                            "Enum": {
                                              "new": [
                                                [
                                                  "Failed",
                                                  "Validation has failed."
                                                ],
                                                [
                                                  "Succeeded",
                                                  "Validation has succeeded."
                                                ],
                                                [
                                                  "Warning",
                                                  "Validation has succeeded with warnings."
                                                ]
                                              ],
                                              "old": [
                                                [
                                                  "Failed",
                                                  ""
                                                ],
                                                [
                                                  "Succeeded",
                                                  ""
                                                ],
                                                [
                                                  "Warning",
                                                  ""
                                                ]
                                              ]
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  ]
                                }
                              }
                            }
                          }
                        ]
                      }
                    ]
                  }
                ]
              },
              {
                "#name": "migrationMode",
                "Enum": {
                  "new": [
                    [
                      "Offline",
                      "Offline migration mode."
                    ],
                    [
                      "Online",
                      "Online migration mode."
                    ]
                  ],
                  "old": [
                    [
                      "Offline",
                      ""
                    ],
                    [
                      "Online",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "migrationOption",
                "Enum": {
                  "new": [
                    [
                      "Validate",
                      "Validate the migration without performing it."
                    ],
                    [
                      "Migrate",
                      "Perform the migration."
                    ],
                    [
                      "ValidateAndMigrate",
                      "Validate and perform the migration."
                    ]
                  ],
                  "old": [
                    [
                      "Validate",
                      ""
                    ],
                    [
                      "Migrate",
                      ""
                    ],
                    [
                      "ValidateAndMigrate",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "sourceType",
                "Enum": {
                  "new": [
                    [
                      "OnPremises",
                      "On-premises PostgreSQL server."
                    ],
                    [
                      "AWS",
                      "Amazon Web Services PostgreSQL server."
                    ],
                    [
                      "GCP",
                      "Google Cloud Platform PostgreSQL server."
                    ],
                    [
                      "AzureVM",
                      "Azure Virtual Machine PostgreSQL server."
                    ],
                    [
                      "PostgreSQLSingleServer",
                      "Azure Database for PostgreSQL single server."
                    ],
                    [
                      "AWS_RDS",
                      "Amazon RDS for PostgreSQL."
                    ],
                    [
                      "AWS_AURORA",
                      "Amazon Aurora for PostgreSQL."
                    ],
                    [
                      "AWS_EC2",
                      "Amazon EC2 for PostgreSQL."
                    ],
                    [
                      "GCP_CloudSQL",
                      "Google Cloud SQL for PostgreSQL."
                    ],
                    [
                      "GCP_AlloyDB",
                      "Google Cloud AlloyDB for PostgreSQL."
                    ],
                    [
                      "GCP_Compute",
                      "Google Compute Engine for PostgreSQL."
                    ],
                    [
                      "EDB",
                      "EnterpriseDB PostgreSQL server."
                    ],
                    [
                      "EDB_Oracle_Server",
                      "EnterpriseDB Oracle Server."
                    ],
                    [
                      "EDB_PostgreSQL",
                      "EnterpriseDB PostgreSQL server."
                    ],
                    [
                      "PostgreSQLFlexibleServer",
                      "Azure Database for PostgreSQL flexible server."
                    ],
                    [
                      "PostgreSQLCosmosDB",
                      ".NET Cosmos DB for PostgreSQL"
                    ],
                    [
                      "Huawei_RDS",
                      "Huawei RDS for PostgreSQL"
                    ],
                    [
                      "Huawei_Compute",
                      "Huawei Compute for PostgreSQL"
                    ],
                    [
                      "Heroku_PostgreSQL",
                      "Heroku PostgreSQL"
                    ],
                    [
                      "Crunchy_PostgreSQL",
                      "Crunchy PostgreSQL"
                    ],
                    [
                      "ApsaraDB_RDS",
                      "ApsaraDB RDS for PostgreSQL"
                    ],
                    [
                      "Digital_Ocean_Droplets",
                      "Digital Ocean Droplets for PostgreSQL"
                    ],
                    [
                      "Digital_Ocean_PostgreSQL",
                      "Digital Ocean PostgreSQL"
                    ],
                    [
                      "Supabase_PostgreSQL",
                      "Supabase PostgreSQL"
                    ]
                  ],
                  "old": [
                    [
                      "OnPremises",
                      ""
                    ],
                    [
                      "AWS",
                      ""
                    ],
                    [
                      "GCP",
                      ""
                    ],
                    [
                      "AzureVM",
                      ""
                    ],
                    [
                      "PostgreSQLSingleServer",
                      ""
                    ],
                    [
                      "AWS_RDS",
                      ""
                    ],
                    [
                      "AWS_AURORA",
                      ""
                    ],
                    [
                      "AWS_EC2",
                      ""
                    ],
                    [
                      "GCP_CloudSQL",
                      ""
                    ],
                    [
                      "GCP_AlloyDB",
                      ""
                    ],
                    [
                      "GCP_Compute",
                      ""
                    ],
                    [
                      "EDB",
                      ""
                    ],
                    [
                      "EDB_Oracle_Server",
                      ""
                    ],
                    [
                      "EDB_PostgreSQL",
                      ""
                    ],
                    [
                      "PostgreSQLFlexibleServer",
                      ""
                    ],
                    [
                      "PostgreSQLCosmosDB",
                      ""
                    ],
                    [
                      "Huawei_RDS",
                      ""
                    ],
                    [
                      "Huawei_Compute",
                      ""
                    ],
                    [
                      "Heroku_PostgreSQL",
                      ""
                    ],
                    [
                      "Crunchy_PostgreSQL",
                      ""
                    ],
                    [
                      "ApsaraDB_RDS",
                      ""
                    ],
                    [
                      "Digital_Ocean_Droplets",
                      ""
                    ],
                    [
                      "Digital_Ocean_PostgreSQL",
                      ""
                    ],
                    [
                      "Supabase_PostgreSQL",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "sslMode",
                "Enum": {
                  "new": [
                    [
                      "Prefer",
                      "Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL."
                    ],
                    [
                      "Require",
                      "Require SSL connection. If the server does not support SSL, the connection will fail."
                    ],
                    [
                      "VerifyCA",
                      "Require SSL connection and verify the server certificate against the CA certificate."
                    ],
                    [
                      "VerifyFull",
                      "Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate."
                    ]
                  ],
                  "old": [
                    [
                      "Prefer",
                      ""
                    ],
                    [
                      "Require",
                      ""
                    ],
                    [
                      "VerifyCA",
                      ""
                    ],
                    [
                      "VerifyFull",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "setupLogicalReplicationOnSourceDbIfNeeded",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Logical replication will be set up on the source server."
                    ],
                    [
                      "False",
                      "Logical replication will not be set up on the source server."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "overwriteDbsInTarget",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Databases on the target server can be overwritten when already present."
                    ],
                    [
                      "False",
                      "Databases on the target server cannot be overwritten when already present."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "migrateRoles",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Roles and permissions will be migrated."
                    ],
                    [
                      "False",
                      "Roles and permissions will not be migrated."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "startDataMigration",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Data migration must start right away."
                    ],
                    [
                      "False",
                      "Data migration must not start right away."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "triggerCutover",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Cutover must be triggered for the entire migration."
                    ],
                    [
                      "False",
                      "Cutover must not be triggered for the entire migration."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "cancel",
                "Enum": {
                  "new": [
                    [
                      "True",
                      "Cancel must be triggered for the entire migration."
                    ],
                    [
                      "False",
                      "Cancel must not be triggered for the entire migration."
                    ]
                  ],
                  "old": [
                    [
                      "True",
                      ""
                    ],
                    [
                      "False",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/migrations
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
migrationListFilter: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
migrationId: string ,
currentStatus:
{
state: enum ,
error: string ,
currentSubStateDetails:
{
currentSubState: enum ,
dbDetails: object ,
validationDetails:
{
status: enum ,
validationStartTimeInUtc: string ,
validationEndTimeInUtc: string ,
serverLevelValidationDetails:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
dbLevelValidationDetails:
[
{
databaseName: string ,
startedOn: string ,
endedOn: string ,
summary:
[
{
type: string ,
state: enum ,
messages:
[
{
state: enum ,
message: string ,
}
,
]
,
}
,
]
,
}
,
]
,
}
,
}
,
}
,
migrationInstanceResourceId: string ,
migrationMode: enum ,
migrationOption: enum ,
sourceType: enum ,
sslMode: enum ,
sourceDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
targetDbServerMetadata:
{
location: string ,
version: string ,
storageMb: integer ,
sku:
{
name: string ,
tier: enum ,
}
,
}
,
sourceDbServerResourceId: string ,
sourceDbServerFullyQualifiedDomainName: string ,
targetDbServerResourceId: string ,
targetDbServerFullyQualifiedDomainName: string ,
secretParameters:
{
adminCredentials:
{
sourceServerPassword: string ,
targetServerPassword: string ,
}
,
sourceServerUsername: string ,
targetServerUsername: string ,
}
,
dbsToMigrate:
[
string ,
]
,
setupLogicalReplicationOnSourceDbIfNeeded: enum ,
overwriteDbsInTarget: enum ,
migrationWindowStartTimeInUtc: string ,
migrationWindowEndTimeInUtc: string ,
migrateRoles: enum ,
startDataMigration: enum ,
triggerCutover: enum ,
dbsToTriggerCutoverOn:
[
string ,
]
,
cancel: enum ,
dbsToCancelMigrationOn:
[
string ,
]
,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Migrations_CheckNameAvailability (updated)
Description Checks if a proposed migration name is valid and available.
Reference Link ¶

⚶ Changes

{
  "#id": "Migrations_CheckNameAvailability",
  "$parameters": {
    "parameters": {
      "$properties": [
        {
          "#name": "reason",
          "Enum": {
            "new": [
              [
                "Invalid",
                "Migration name is invalid."
              ],
              [
                "AlreadyExists",
                "Migration name already exists."
              ]
            ],
            "old": [
              [
                "Invalid",
                ""
              ],
              [
                "AlreadyExists",
                ""
              ]
            ]
          }
        }
      ]
    }
  },
  "$responses": {
    "200": {
      "$properties": [
        {
          "#name": "reason",
          "Enum": {
            "new": [
              [
                "Invalid",
                "Migration name is invalid."
              ],
              [
                "AlreadyExists",
                "Migration name already exists."
              ]
            ],
            "old": [
              [
                "Invalid",
                ""
              ],
              [
                "AlreadyExists",
                ""
              ]
            ]
          }
        }
      ]
    }
  }
}

⚼ Request

POST:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/checkMigrationNameAvailability
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
parameters:
{
name: string ,
type: string ,
nameAvailable: boolean ,
reason: enum ,
message: string ,
}
,
}

⚐ Response (200)

{
name: string ,
type: string ,
nameAvailable: boolean ,
reason: enum ,
message: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Operations_List (updated)
Description Lists all available REST API operations.
Reference Link ¶

⚶ Changes

{
  "#id": "Operations_List",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": [
            {
              "#name": "origin",
              "Enum": {
                "new": [
                  [
                    "NotSpecified",
                    "The origin is not specified."
                  ],
                  [
                    "user",
                    "The operation is initiated by a user."
                  ],
                  [
                    "system",
                    "The operation is initiated by the system."
                  ]
                ],
                "old": [
                  [
                    "NotSpecified",
                    ""
                  ],
                  [
                    "user",
                    ""
                  ],
                  [
                    "system",
                    ""
                  ]
                ]
              }
            }
          ]
        }
      }
    }
  }
}

⚼ Request

GET:  /providers/Microsoft.DBforPostgreSQL/operations
{
api-version: string ,
}

⚐ Response (200)

{
value:
[
{
name: string ,
display:
{
provider: string ,
resource: string ,
operation: string ,
description: string ,
}
,
isDataAction: boolean ,
origin: enum ,
properties: object ,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_CreateOrUpdate (updated)
Description Creates a new server.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_CreateOrUpdate",
  "$parameters": {
    "parameters": {
      "$properties": {
        "sku": [
          {
            "#name": "tier",
            "Enum": {
              "new": [
                [
                  "Burstable",
                  "Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements."
                ],
                [
                  "GeneralPurpose",
                  "Balanced compute and memory for most workloads, offering scalable performance and I/O throughput."
                ],
                [
                  "MemoryOptimized",
                  "High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency."
                ]
              ],
              "old": [
                [
                  "Burstable",
                  ""
                ],
                [
                  "GeneralPurpose",
                  ""
                ],
                [
                  "MemoryOptimized",
                  ""
                ]
              ]
            }
          }
        ],
        "identity": [
          {
            "#name": "type",
            "Enum": {
              "new": [
                [
                  "None",
                  "No managed identity is assigned to the server."
                ],
                [
                  "UserAssigned",
                  "One or more managed identities provided by the user are assigned to the server."
                ],
                [
                  "SystemAssigned",
                  "Azure automatically creates and manages the identity associated to the lifecycle of the server."
                ],
                [
                  "SystemAssigned,UserAssigned",
                  "Both system-assigned and user-assigned identities are assigned to the server."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "UserAssigned",
                  ""
                ],
                [
                  "SystemAssigned",
                  ""
                ],
                [
                  "SystemAssigned,UserAssigned",
                  ""
                ]
              ]
            }
          }
        ],
        "properties": [
          {
            "#name": "version",
            "Enum": {
              "new": [
                [
                  "17",
                  "PostgreSQL 17."
                ],
                [
                  "16",
                  "PostgreSQL 16."
                ],
                [
                  "15",
                  "PostgreSQL 15."
                ],
                [
                  "14",
                  "PostgreSQL 14."
                ],
                [
                  "13",
                  "PostgreSQL 13."
                ],
                [
                  "12",
                  "PostgreSQL 12."
                ],
                [
                  "11",
                  "PostgreSQL 11."
                ]
              ],
              "old": [
                [
                  "17",
                  ""
                ],
                [
                  "16",
                  ""
                ],
                [
                  "15",
                  ""
                ],
                [
                  "14",
                  ""
                ],
                [
                  "13",
                  ""
                ],
                [
                  "12",
                  ""
                ],
                [
                  "11",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "state",
            "Enum": {
              "new": [
                [
                  "Ready",
                  "Server is healthy and not undergoing any operations at the management or control plane level. This doesn't mean that the server is fully operational at the data plane level."
                ],
                [
                  "Dropping",
                  "Server is being deleted."
                ],
                [
                  "Disabled",
                  "Server is disabled. Typical reasons include: the subscription on which the server is deployed is explicitly disabled or canceled by the administrator, the spending limit has been reached, or the bill is past due. May also happen when the server is being moved to another resource group or subscription."
                ],
                [
                  "Starting",
                  "PostgreSQL database engine is being restarted."
                ],
                [
                  "Stopping",
                  "Compute resources associated with the server are being stopped and deallocated. If the server has high availability enabled, the compute resources of the standby server are also stopped and deallocated."
                ],
                [
                  "Stopped",
                  "Compute resources associated with the server are being stopped and deallocated."
                ],
                [
                  "Updating",
                  "Server is undergoing some changes which may or may not impact the availability of the PostgreSQL database engine. For example, the compute resources of the server are being scaled up or down, which may cause temporary unavailability of the database engine. Or, for example, a firewall rule is being added or removed, which doesn't cause any unavailability of the database engine."
                ],
                [
                  "Restarting",
                  "PostgreSQL database engine is being restarted."
                ],
                [
                  "Inaccessible",
                  "Server isn't accessible, because the key provided to encrypt and decrypt the data is in invalid state."
                ],
                [
                  "Provisioning",
                  "Server is in the process of being created."
                ]
              ],
              "old": [
                [
                  "Ready",
                  ""
                ],
                [
                  "Dropping",
                  ""
                ],
                [
                  "Disabled",
                  ""
                ],
                [
                  "Starting",
                  ""
                ],
                [
                  "Stopping",
                  ""
                ],
                [
                  "Stopped",
                  ""
                ],
                [
                  "Updating",
                  ""
                ],
                [
                  "Restarting",
                  ""
                ],
                [
                  "Inaccessible",
                  ""
                ],
                [
                  "Provisioning",
                  ""
                ]
              ]
            }
          },
          {
            "storage": [
              {
                "#name": "autoGrow",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size."
                    ],
                    [
                      "Disabled",
                      "Server should not automatically grow storage size when available space is nearing zero."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "tier",
                "Enum": {
                  "new": [
                    [
                      "P1",
                      "Entry-level SSD for minimal IOPS, ideal for light development or testing workloads."
                    ],
                    [
                      "P2",
                      "Slightly higher IOPS for small-scale applications needing consistent low latency."
                    ],
                    [
                      "P3",
                      "Balanced performance for basic production workloads with moderate throughput."
                    ],
                    [
                      "P4",
                      "Enhanced IOPS for growing apps with predictable performance needs."
                    ],
                    [
                      "P6",
                      "Mid-tier SSD for steady workloads requiring reliable throughput and latency."
                    ],
                    [
                      "P10",
                      "Popular choice for general-purpose production workloads with scalable performance."
                    ],
                    [
                      "P15",
                      "High IOPS tier for demanding apps with frequent read/write operations."
                    ],
                    [
                      "P20",
                      "Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads."
                    ],
                    [
                      "P30",
                      "Balanced tier for moderate throughput and latency-sensitive applications."
                    ],
                    [
                      "P40",
                      "Enhanced performance for growing production workloads with consistent IOPS demands."
                    ],
                    [
                      "P50",
                      "Optimized for enterprise-grade applications needing sustained high throughput."
                    ],
                    [
                      "P60",
                      "High-capacity tier for large databases and analytics workloads with elevated IOPS."
                    ],
                    [
                      "P70",
                      "Designed for mission-critical systems requiring ultra-low latency and high concurrency."
                    ],
                    [
                      "P80",
                      "Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads."
                    ]
                  ],
                  "old": [
                    [
                      "P1",
                      ""
                    ],
                    [
                      "P2",
                      ""
                    ],
                    [
                      "P3",
                      ""
                    ],
                    [
                      "P4",
                      ""
                    ],
                    [
                      "P6",
                      ""
                    ],
                    [
                      "P10",
                      ""
                    ],
                    [
                      "P15",
                      ""
                    ],
                    [
                      "P20",
                      ""
                    ],
                    [
                      "P30",
                      ""
                    ],
                    [
                      "P40",
                      ""
                    ],
                    [
                      "P50",
                      ""
                    ],
                    [
                      "P60",
                      ""
                    ],
                    [
                      "P70",
                      ""
                    ],
                    [
                      "P80",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "Premium_LRS",
                      "Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads."
                    ],
                    [
                      "PremiumV2_LRS",
                      "Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads."
                    ],
                    [
                      "UltraSSD_LRS",
                      "High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications."
                    ]
                  ],
                  "old": [
                    [
                      "Premium_LRS",
                      ""
                    ],
                    [
                      "PremiumV2_LRS",
                      ""
                    ],
                    [
                      "UltraSSD_LRS",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "authConfig": [
              {
                "#name": "activeDirectoryAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports Microsoft Entra authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support Microsoft Entra authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "passwordAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports password based authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support password based authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "dataEncryption": [
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "SystemManaged",
                      "Encryption managed by Azure using platform managed keys for simplicity and compliance."
                    ],
                    [
                      "AzureKeyVault",
                      "Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security."
                    ]
                  ],
                  "old": [
                    [
                      "SystemManaged",
                      ""
                    ],
                    [
                      "AzureKeyVault",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "primaryEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "geoBackupEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "backup": [
              {
                "#name": "geoRedundantBackup",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server is configured to create geographically redundant backups."
                    ],
                    [
                      "Disabled",
                      "Server is not configured to create geographically redundant backups."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "network": [
              {
                "#name": "publicNetworkAccess",
                "Description": {
                  "new": "Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed.",
                  "old": "Indicates if public network access is enabled or not."
                },
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server."
                    ],
                    [
                      "Disabled",
                      "Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "highAvailability": [
              {
                "#name": "mode",
                "Enum": {
                  "new": [
                    [
                      "Disabled",
                      "High availability is disabled for the server."
                    ],
                    [
                      "ZoneRedundant",
                      "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                    ],
                    [
                      "SameZone",
                      "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                    ]
                  ],
                  "old": [
                    [
                      "Disabled",
                      ""
                    ],
                    [
                      "ZoneRedundant",
                      ""
                    ],
                    [
                      "SameZone",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "NotEnabled",
                      "High availability is not enabled for the server."
                    ],
                    [
                      "CreatingStandby",
                      "Standby server is being created."
                    ],
                    [
                      "ReplicatingData",
                      "Data is being replicated to the standby server."
                    ],
                    [
                      "FailingOver",
                      "Failover operation to the standby server is in progress."
                    ],
                    [
                      "Healthy",
                      "Standby server is healthy and ready to take over in case of a failover."
                    ],
                    [
                      "RemovingStandby",
                      "Standby server is being removed."
                    ]
                  ],
                  "old": [
                    [
                      "NotEnabled",
                      ""
                    ],
                    [
                      "CreatingStandby",
                      ""
                    ],
                    [
                      "ReplicatingData",
                      ""
                    ],
                    [
                      "FailingOver",
                      ""
                    ],
                    [
                      "Healthy",
                      ""
                    ],
                    [
                      "RemovingStandby",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "#name": "replicationRole",
            "Enum": {
              "new": [
                [
                  "None",
                  "No replication role assigned; the server operates independently."
                ],
                [
                  "Primary",
                  "Acts as the source server for replication to one or more replicas."
                ],
                [
                  "AsyncReplica",
                  "Receives data asynchronously from a primary server within the same region."
                ],
                [
                  "GeoAsyncReplica",
                  "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "Primary",
                  ""
                ],
                [
                  "AsyncReplica",
                  ""
                ],
                [
                  "GeoAsyncReplica",
                  ""
                ]
              ]
            }
          },
          {
            "replica": [
              {
                "#name": "role",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No replication role assigned; the server operates independently."
                    ],
                    [
                      "Primary",
                      "Acts as the source server for replication to one or more replicas."
                    ],
                    [
                      "AsyncReplica",
                      "Receives data asynchronously from a primary server within the same region."
                    ],
                    [
                      "GeoAsyncReplica",
                      "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "Primary",
                      ""
                    ],
                    [
                      "AsyncReplica",
                      ""
                    ],
                    [
                      "GeoAsyncReplica",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "replicationState",
                "Enum": {
                  "new": [
                    [
                      "Active",
                      "Read replica is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "Read replica is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "Read replica is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "Read replica is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "Read replica is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ],
                  "old": [
                    [
                      "Active",
                      "The read replica server is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "The read replica server is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "The read replica server is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "The read replica server is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "The read replica server is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ]
                }
              }
            ]
          },
          {
            "#name": "createMode",
            "Enum": {
              "new": [
                [
                  "Default",
                  "If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'."
                ],
                [
                  "Create",
                  "Operation creates a new server."
                ],
                [
                  "Update",
                  "Operation updates an existing server."
                ],
                [
                  "PointInTimeRestore",
                  "Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time."
                ],
                [
                  "GeoRestore",
                  "Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled."
                ],
                [
                  "Replica",
                  "Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary."
                ],
                [
                  "ReviveDropped",
                  "Operation creates a new server, initialized with the backup of a server that was recently deleted."
                ]
              ],
              "old": [
                [
                  "Default",
                  ""
                ],
                [
                  "Create",
                  ""
                ],
                [
                  "Update",
                  ""
                ],
                [
                  "PointInTimeRestore",
                  ""
                ],
                [
                  "GeoRestore",
                  ""
                ],
                [
                  "Replica",
                  ""
                ],
                [
                  "ReviveDropped",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PUT:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
parameters:
{
sku:
{
name: string ,
tier: enum ,
}
,
identity:
{
userAssignedIdentities: object ,
principalId: string ,
type: enum ,
tenantId: string ,
}
,
properties:
{
administratorLogin: string ,
administratorLoginPassword: string ,
version: enum ,
minorVersion: string ,
state: enum ,
fullyQualifiedDomainName: string ,
storage:
{
storageSizeGB: integer ,
autoGrow: enum ,
tier: enum ,
iops: integer ,
throughput: integer ,
type: enum ,
}
,
authConfig:
{
activeDirectoryAuth: enum ,
passwordAuth: enum ,
tenantId: string ,
}
,
dataEncryption:
{
primaryKeyURI: string ,
primaryUserAssignedIdentityId: string ,
geoBackupKeyURI: string ,
geoBackupUserAssignedIdentityId: string ,
type: enum ,
primaryEncryptionKeyStatus: enum ,
geoBackupEncryptionKeyStatus: enum ,
}
,
backup:
{
backupRetentionDays: integer ,
geoRedundantBackup: enum ,
earliestRestoreDate: string ,
}
,
network:
{
publicNetworkAccess: enum ,
delegatedSubnetResourceId: string ,
privateDnsZoneArmResourceId: string ,
}
,
highAvailability:
{
mode: enum ,
state: enum ,
standbyAvailabilityZone: string ,
}
,
maintenanceWindow:
{
customWindow: string ,
startHour: integer ,
startMinute: integer ,
dayOfWeek: integer ,
}
,
sourceServerResourceId: string ,
pointInTimeUTC: string ,
availabilityZone: string ,
replicationRole: enum ,
replicaCapacity: integer ,
replica:
{
role: enum ,
capacity: integer ,
replicationState: enum ,
promoteMode: enum ,
promoteOption: enum ,
}
,
createMode: enum ,
privateEndpointConnections:
[
{
properties:
{
groupIds:
[
string ,
]
,
privateEndpoint:
{
id: string ,
}
,
privateLinkServiceConnectionState:
{
status: enum ,
description: string ,
actionsRequired: string ,
}
,
provisioningState: enum ,
}
,
}
,
]
,
cluster:
{
clusterSize: integer ,
defaultDatabaseName: string ,
}
,
}
,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_Update (updated)
Description Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_Update",
  "$parameters": {
    "parameters": {
      "$properties": {
        "sku": [
          {
            "#name": "tier",
            "Enum": {
              "new": [
                [
                  "Burstable",
                  "Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements."
                ],
                [
                  "GeneralPurpose",
                  "Balanced compute and memory for most workloads, offering scalable performance and I/O throughput."
                ],
                [
                  "MemoryOptimized",
                  "High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency."
                ]
              ],
              "old": [
                [
                  "Burstable",
                  ""
                ],
                [
                  "GeneralPurpose",
                  ""
                ],
                [
                  "MemoryOptimized",
                  ""
                ]
              ]
            }
          }
        ],
        "identity": [
          {
            "#name": "type",
            "Enum": {
              "new": [
                [
                  "None",
                  "No managed identity is assigned to the server."
                ],
                [
                  "UserAssigned",
                  "One or more managed identities provided by the user are assigned to the server."
                ],
                [
                  "SystemAssigned",
                  "Azure automatically creates and manages the identity associated to the lifecycle of the server."
                ],
                [
                  "SystemAssigned,UserAssigned",
                  "Both system-assigned and user-assigned identities are assigned to the server."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "UserAssigned",
                  ""
                ],
                [
                  "SystemAssigned",
                  ""
                ],
                [
                  "SystemAssigned,UserAssigned",
                  ""
                ]
              ]
            }
          }
        ],
        "properties": [
          {
            "#name": "version",
            "Enum": {
              "new": [
                [
                  "17",
                  "PostgreSQL 17."
                ],
                [
                  "16",
                  "PostgreSQL 16."
                ],
                [
                  "15",
                  "PostgreSQL 15."
                ],
                [
                  "14",
                  "PostgreSQL 14."
                ],
                [
                  "13",
                  "PostgreSQL 13."
                ],
                [
                  "12",
                  "PostgreSQL 12."
                ],
                [
                  "11",
                  "PostgreSQL 11."
                ]
              ],
              "old": [
                [
                  "17",
                  ""
                ],
                [
                  "16",
                  ""
                ],
                [
                  "15",
                  ""
                ],
                [
                  "14",
                  ""
                ],
                [
                  "13",
                  ""
                ],
                [
                  "12",
                  ""
                ],
                [
                  "11",
                  ""
                ]
              ]
            }
          },
          {
            "storage": [
              {
                "#name": "autoGrow",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size."
                    ],
                    [
                      "Disabled",
                      "Server should not automatically grow storage size when available space is nearing zero."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "tier",
                "Enum": {
                  "new": [
                    [
                      "P1",
                      "Entry-level SSD for minimal IOPS, ideal for light development or testing workloads."
                    ],
                    [
                      "P2",
                      "Slightly higher IOPS for small-scale applications needing consistent low latency."
                    ],
                    [
                      "P3",
                      "Balanced performance for basic production workloads with moderate throughput."
                    ],
                    [
                      "P4",
                      "Enhanced IOPS for growing apps with predictable performance needs."
                    ],
                    [
                      "P6",
                      "Mid-tier SSD for steady workloads requiring reliable throughput and latency."
                    ],
                    [
                      "P10",
                      "Popular choice for general-purpose production workloads with scalable performance."
                    ],
                    [
                      "P15",
                      "High IOPS tier for demanding apps with frequent read/write operations."
                    ],
                    [
                      "P20",
                      "Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads."
                    ],
                    [
                      "P30",
                      "Balanced tier for moderate throughput and latency-sensitive applications."
                    ],
                    [
                      "P40",
                      "Enhanced performance for growing production workloads with consistent IOPS demands."
                    ],
                    [
                      "P50",
                      "Optimized for enterprise-grade applications needing sustained high throughput."
                    ],
                    [
                      "P60",
                      "High-capacity tier for large databases and analytics workloads with elevated IOPS."
                    ],
                    [
                      "P70",
                      "Designed for mission-critical systems requiring ultra-low latency and high concurrency."
                    ],
                    [
                      "P80",
                      "Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads."
                    ]
                  ],
                  "old": [
                    [
                      "P1",
                      ""
                    ],
                    [
                      "P2",
                      ""
                    ],
                    [
                      "P3",
                      ""
                    ],
                    [
                      "P4",
                      ""
                    ],
                    [
                      "P6",
                      ""
                    ],
                    [
                      "P10",
                      ""
                    ],
                    [
                      "P15",
                      ""
                    ],
                    [
                      "P20",
                      ""
                    ],
                    [
                      "P30",
                      ""
                    ],
                    [
                      "P40",
                      ""
                    ],
                    [
                      "P50",
                      ""
                    ],
                    [
                      "P60",
                      ""
                    ],
                    [
                      "P70",
                      ""
                    ],
                    [
                      "P80",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "Premium_LRS",
                      "Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads."
                    ],
                    [
                      "PremiumV2_LRS",
                      "Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads."
                    ],
                    [
                      "UltraSSD_LRS",
                      "High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications."
                    ]
                  ],
                  "old": [
                    [
                      "Premium_LRS",
                      ""
                    ],
                    [
                      "PremiumV2_LRS",
                      ""
                    ],
                    [
                      "UltraSSD_LRS",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "backup": [
              {
                "#name": "geoRedundantBackup",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server is configured to create geographically redundant backups."
                    ],
                    [
                      "Disabled",
                      "Server is not configured to create geographically redundant backups."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "highAvailability": [
              {
                "#name": "mode",
                "Enum": {
                  "new": [
                    [
                      "Disabled",
                      "High availability is disabled for the server."
                    ],
                    [
                      "ZoneRedundant",
                      "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                    ],
                    [
                      "SameZone",
                      "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                    ]
                  ],
                  "old": [
                    [
                      "Disabled",
                      ""
                    ],
                    [
                      "ZoneRedundant",
                      ""
                    ],
                    [
                      "SameZone",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "NotEnabled",
                      "High availability is not enabled for the server."
                    ],
                    [
                      "CreatingStandby",
                      "Standby server is being created."
                    ],
                    [
                      "ReplicatingData",
                      "Data is being replicated to the standby server."
                    ],
                    [
                      "FailingOver",
                      "Failover operation to the standby server is in progress."
                    ],
                    [
                      "Healthy",
                      "Standby server is healthy and ready to take over in case of a failover."
                    ],
                    [
                      "RemovingStandby",
                      "Standby server is being removed."
                    ]
                  ],
                  "old": [
                    [
                      "NotEnabled",
                      ""
                    ],
                    [
                      "CreatingStandby",
                      ""
                    ],
                    [
                      "ReplicatingData",
                      ""
                    ],
                    [
                      "FailingOver",
                      ""
                    ],
                    [
                      "Healthy",
                      ""
                    ],
                    [
                      "RemovingStandby",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "authConfig": [
              {
                "#name": "activeDirectoryAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports Microsoft Entra authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support Microsoft Entra authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "passwordAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports password based authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support password based authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "dataEncryption": [
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "SystemManaged",
                      "Encryption managed by Azure using platform managed keys for simplicity and compliance."
                    ],
                    [
                      "AzureKeyVault",
                      "Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security."
                    ]
                  ],
                  "old": [
                    [
                      "SystemManaged",
                      ""
                    ],
                    [
                      "AzureKeyVault",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "primaryEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "geoBackupEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "#name": "createMode",
            "Enum": {
              "new": [
                [
                  "Default",
                  "It's equivalent to 'Update'."
                ],
                [
                  "Update",
                  "Operation updates an existing server."
                ]
              ],
              "old": [
                [
                  "Default",
                  ""
                ],
                [
                  "Update",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "replicationRole",
            "Enum": {
              "new": [
                [
                  "None",
                  "No replication role assigned; the server operates independently."
                ],
                [
                  "Primary",
                  "Acts as the source server for replication to one or more replicas."
                ],
                [
                  "AsyncReplica",
                  "Receives data asynchronously from a primary server within the same region."
                ],
                [
                  "GeoAsyncReplica",
                  "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "Primary",
                  ""
                ],
                [
                  "AsyncReplica",
                  ""
                ],
                [
                  "GeoAsyncReplica",
                  ""
                ]
              ]
            }
          },
          {
            "replica": [
              {
                "#name": "role",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No replication role assigned; the server operates independently."
                    ],
                    [
                      "Primary",
                      "Acts as the source server for replication to one or more replicas."
                    ],
                    [
                      "AsyncReplica",
                      "Receives data asynchronously from a primary server within the same region."
                    ],
                    [
                      "GeoAsyncReplica",
                      "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "Primary",
                      ""
                    ],
                    [
                      "AsyncReplica",
                      ""
                    ],
                    [
                      "GeoAsyncReplica",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "replicationState",
                "Enum": {
                  "new": [
                    [
                      "Active",
                      "Read replica is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "Read replica is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "Read replica is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "Read replica is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "Read replica is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ],
                  "old": [
                    [
                      "Active",
                      "The read replica server is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "The read replica server is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "The read replica server is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "The read replica server is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "The read replica server is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ]
                }
              }
            ]
          },
          {
            "network": [
              {
                "#name": "publicNetworkAccess",
                "Description": {
                  "new": "Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed.",
                  "old": "Indicates if public network access is enabled or not."
                },
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server."
                    ],
                    [
                      "Disabled",
                      "Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

PATCH:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
parameters:
{
sku:
{
name: string ,
tier: enum ,
}
,
identity:
{
userAssignedIdentities: object ,
principalId: string ,
type: enum ,
tenantId: string ,
}
,
properties:
{
administratorLogin: string ,
administratorLoginPassword: string ,
version: enum ,
storage:
{
storageSizeGB: integer ,
autoGrow: enum ,
tier: enum ,
iops: integer ,
throughput: integer ,
type: enum ,
}
,
backup:
{
backupRetentionDays: integer ,
geoRedundantBackup: enum ,
earliestRestoreDate: string ,
}
,
highAvailability:
{
mode: enum ,
state: enum ,
standbyAvailabilityZone: string ,
}
,
maintenanceWindow:
{
customWindow: string ,
startHour: integer ,
startMinute: integer ,
dayOfWeek: integer ,
}
,
authConfig:
{
activeDirectoryAuth: enum ,
passwordAuth: enum ,
tenantId: string ,
}
,
dataEncryption:
{
primaryKeyURI: string ,
primaryUserAssignedIdentityId: string ,
geoBackupKeyURI: string ,
geoBackupUserAssignedIdentityId: string ,
type: enum ,
primaryEncryptionKeyStatus: enum ,
geoBackupEncryptionKeyStatus: enum ,
}
,
createMode: enum ,
replicationRole: enum ,
replica:
{
role: enum ,
capacity: integer ,
replicationState: enum ,
promoteMode: enum ,
promoteOption: enum ,
}
,
network:
{
publicNetworkAccess: enum ,
delegatedSubnetResourceId: string ,
privateDnsZoneArmResourceId: string ,
}
,
cluster:
{
clusterSize: integer ,
defaultDatabaseName: string ,
}
,
}
,
tags: object ,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_Get (updated)
Description Gets information about an existing server.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_Get",
  "$responses": {
    "200": {
      "$properties": {
        "sku": [
          {
            "#name": "tier",
            "Enum": {
              "new": [
                [
                  "Burstable",
                  "Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements."
                ],
                [
                  "GeneralPurpose",
                  "Balanced compute and memory for most workloads, offering scalable performance and I/O throughput."
                ],
                [
                  "MemoryOptimized",
                  "High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency."
                ]
              ],
              "old": [
                [
                  "Burstable",
                  ""
                ],
                [
                  "GeneralPurpose",
                  ""
                ],
                [
                  "MemoryOptimized",
                  ""
                ]
              ]
            }
          }
        ],
        "identity": [
          {
            "#name": "type",
            "Enum": {
              "new": [
                [
                  "None",
                  "No managed identity is assigned to the server."
                ],
                [
                  "UserAssigned",
                  "One or more managed identities provided by the user are assigned to the server."
                ],
                [
                  "SystemAssigned",
                  "Azure automatically creates and manages the identity associated to the lifecycle of the server."
                ],
                [
                  "SystemAssigned,UserAssigned",
                  "Both system-assigned and user-assigned identities are assigned to the server."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "UserAssigned",
                  ""
                ],
                [
                  "SystemAssigned",
                  ""
                ],
                [
                  "SystemAssigned,UserAssigned",
                  ""
                ]
              ]
            }
          }
        ],
        "properties": [
          {
            "#name": "version",
            "Enum": {
              "new": [
                [
                  "17",
                  "PostgreSQL 17."
                ],
                [
                  "16",
                  "PostgreSQL 16."
                ],
                [
                  "15",
                  "PostgreSQL 15."
                ],
                [
                  "14",
                  "PostgreSQL 14."
                ],
                [
                  "13",
                  "PostgreSQL 13."
                ],
                [
                  "12",
                  "PostgreSQL 12."
                ],
                [
                  "11",
                  "PostgreSQL 11."
                ]
              ],
              "old": [
                [
                  "17",
                  ""
                ],
                [
                  "16",
                  ""
                ],
                [
                  "15",
                  ""
                ],
                [
                  "14",
                  ""
                ],
                [
                  "13",
                  ""
                ],
                [
                  "12",
                  ""
                ],
                [
                  "11",
                  ""
                ]
              ]
            }
          },
          {
            "#name": "state",
            "Enum": {
              "new": [
                [
                  "Ready",
                  "Server is healthy and not undergoing any operations at the management or control plane level. This doesn't mean that the server is fully operational at the data plane level."
                ],
                [
                  "Dropping",
                  "Server is being deleted."
                ],
                [
                  "Disabled",
                  "Server is disabled. Typical reasons include: the subscription on which the server is deployed is explicitly disabled or canceled by the administrator, the spending limit has been reached, or the bill is past due. May also happen when the server is being moved to another resource group or subscription."
                ],
                [
                  "Starting",
                  "PostgreSQL database engine is being restarted."
                ],
                [
                  "Stopping",
                  "Compute resources associated with the server are being stopped and deallocated. If the server has high availability enabled, the compute resources of the standby server are also stopped and deallocated."
                ],
                [
                  "Stopped",
                  "Compute resources associated with the server are being stopped and deallocated."
                ],
                [
                  "Updating",
                  "Server is undergoing some changes which may or may not impact the availability of the PostgreSQL database engine. For example, the compute resources of the server are being scaled up or down, which may cause temporary unavailability of the database engine. Or, for example, a firewall rule is being added or removed, which doesn't cause any unavailability of the database engine."
                ],
                [
                  "Restarting",
                  "PostgreSQL database engine is being restarted."
                ],
                [
                  "Inaccessible",
                  "Server isn't accessible, because the key provided to encrypt and decrypt the data is in invalid state."
                ],
                [
                  "Provisioning",
                  "Server is in the process of being created."
                ]
              ],
              "old": [
                [
                  "Ready",
                  ""
                ],
                [
                  "Dropping",
                  ""
                ],
                [
                  "Disabled",
                  ""
                ],
                [
                  "Starting",
                  ""
                ],
                [
                  "Stopping",
                  ""
                ],
                [
                  "Stopped",
                  ""
                ],
                [
                  "Updating",
                  ""
                ],
                [
                  "Restarting",
                  ""
                ],
                [
                  "Inaccessible",
                  ""
                ],
                [
                  "Provisioning",
                  ""
                ]
              ]
            }
          },
          {
            "storage": [
              {
                "#name": "autoGrow",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size."
                    ],
                    [
                      "Disabled",
                      "Server should not automatically grow storage size when available space is nearing zero."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "tier",
                "Enum": {
                  "new": [
                    [
                      "P1",
                      "Entry-level SSD for minimal IOPS, ideal for light development or testing workloads."
                    ],
                    [
                      "P2",
                      "Slightly higher IOPS for small-scale applications needing consistent low latency."
                    ],
                    [
                      "P3",
                      "Balanced performance for basic production workloads with moderate throughput."
                    ],
                    [
                      "P4",
                      "Enhanced IOPS for growing apps with predictable performance needs."
                    ],
                    [
                      "P6",
                      "Mid-tier SSD for steady workloads requiring reliable throughput and latency."
                    ],
                    [
                      "P10",
                      "Popular choice for general-purpose production workloads with scalable performance."
                    ],
                    [
                      "P15",
                      "High IOPS tier for demanding apps with frequent read/write operations."
                    ],
                    [
                      "P20",
                      "Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads."
                    ],
                    [
                      "P30",
                      "Balanced tier for moderate throughput and latency-sensitive applications."
                    ],
                    [
                      "P40",
                      "Enhanced performance for growing production workloads with consistent IOPS demands."
                    ],
                    [
                      "P50",
                      "Optimized for enterprise-grade applications needing sustained high throughput."
                    ],
                    [
                      "P60",
                      "High-capacity tier for large databases and analytics workloads with elevated IOPS."
                    ],
                    [
                      "P70",
                      "Designed for mission-critical systems requiring ultra-low latency and high concurrency."
                    ],
                    [
                      "P80",
                      "Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads."
                    ]
                  ],
                  "old": [
                    [
                      "P1",
                      ""
                    ],
                    [
                      "P2",
                      ""
                    ],
                    [
                      "P3",
                      ""
                    ],
                    [
                      "P4",
                      ""
                    ],
                    [
                      "P6",
                      ""
                    ],
                    [
                      "P10",
                      ""
                    ],
                    [
                      "P15",
                      ""
                    ],
                    [
                      "P20",
                      ""
                    ],
                    [
                      "P30",
                      ""
                    ],
                    [
                      "P40",
                      ""
                    ],
                    [
                      "P50",
                      ""
                    ],
                    [
                      "P60",
                      ""
                    ],
                    [
                      "P70",
                      ""
                    ],
                    [
                      "P80",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "Premium_LRS",
                      "Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads."
                    ],
                    [
                      "PremiumV2_LRS",
                      "Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads."
                    ],
                    [
                      "UltraSSD_LRS",
                      "High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications."
                    ]
                  ],
                  "old": [
                    [
                      "Premium_LRS",
                      ""
                    ],
                    [
                      "PremiumV2_LRS",
                      ""
                    ],
                    [
                      "UltraSSD_LRS",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "authConfig": [
              {
                "#name": "activeDirectoryAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports Microsoft Entra authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support Microsoft Entra authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "passwordAuth",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server supports password based authentication."
                    ],
                    [
                      "Disabled",
                      "Server doesn't support password based authentication."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "dataEncryption": [
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "SystemManaged",
                      "Encryption managed by Azure using platform managed keys for simplicity and compliance."
                    ],
                    [
                      "AzureKeyVault",
                      "Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security."
                    ]
                  ],
                  "old": [
                    [
                      "SystemManaged",
                      ""
                    ],
                    [
                      "AzureKeyVault",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "primaryEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "geoBackupEncryptionKeyStatus",
                "Enum": {
                  "new": [
                    [
                      "Valid",
                      "Key is valid and can be used for encryption."
                    ],
                    [
                      "Invalid",
                      "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                    ]
                  ],
                  "old": [
                    [
                      "Valid",
                      ""
                    ],
                    [
                      "Invalid",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "backup": [
              {
                "#name": "geoRedundantBackup",
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Server is configured to create geographically redundant backups."
                    ],
                    [
                      "Disabled",
                      "Server is not configured to create geographically redundant backups."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "network": [
              {
                "#name": "publicNetworkAccess",
                "Description": {
                  "new": "Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed.",
                  "old": "Indicates if public network access is enabled or not."
                },
                "Enum": {
                  "new": [
                    [
                      "Enabled",
                      "Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server."
                    ],
                    [
                      "Disabled",
                      "Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints."
                    ]
                  ],
                  "old": [
                    [
                      "Enabled",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "highAvailability": [
              {
                "#name": "mode",
                "Enum": {
                  "new": [
                    [
                      "Disabled",
                      "High availability is disabled for the server."
                    ],
                    [
                      "ZoneRedundant",
                      "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                    ],
                    [
                      "SameZone",
                      "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                    ]
                  ],
                  "old": [
                    [
                      "Disabled",
                      ""
                    ],
                    [
                      "ZoneRedundant",
                      ""
                    ],
                    [
                      "SameZone",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "NotEnabled",
                      "High availability is not enabled for the server."
                    ],
                    [
                      "CreatingStandby",
                      "Standby server is being created."
                    ],
                    [
                      "ReplicatingData",
                      "Data is being replicated to the standby server."
                    ],
                    [
                      "FailingOver",
                      "Failover operation to the standby server is in progress."
                    ],
                    [
                      "Healthy",
                      "Standby server is healthy and ready to take over in case of a failover."
                    ],
                    [
                      "RemovingStandby",
                      "Standby server is being removed."
                    ]
                  ],
                  "old": [
                    [
                      "NotEnabled",
                      ""
                    ],
                    [
                      "CreatingStandby",
                      ""
                    ],
                    [
                      "ReplicatingData",
                      ""
                    ],
                    [
                      "FailingOver",
                      ""
                    ],
                    [
                      "Healthy",
                      ""
                    ],
                    [
                      "RemovingStandby",
                      ""
                    ]
                  ]
                }
              }
            ]
          },
          {
            "#name": "replicationRole",
            "Enum": {
              "new": [
                [
                  "None",
                  "No replication role assigned; the server operates independently."
                ],
                [
                  "Primary",
                  "Acts as the source server for replication to one or more replicas."
                ],
                [
                  "AsyncReplica",
                  "Receives data asynchronously from a primary server within the same region."
                ],
                [
                  "GeoAsyncReplica",
                  "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                ]
              ],
              "old": [
                [
                  "None",
                  ""
                ],
                [
                  "Primary",
                  ""
                ],
                [
                  "AsyncReplica",
                  ""
                ],
                [
                  "GeoAsyncReplica",
                  ""
                ]
              ]
            }
          },
          {
            "replica": [
              {
                "#name": "role",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No replication role assigned; the server operates independently."
                    ],
                    [
                      "Primary",
                      "Acts as the source server for replication to one or more replicas."
                    ],
                    [
                      "AsyncReplica",
                      "Receives data asynchronously from a primary server within the same region."
                    ],
                    [
                      "GeoAsyncReplica",
                      "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "Primary",
                      ""
                    ],
                    [
                      "AsyncReplica",
                      ""
                    ],
                    [
                      "GeoAsyncReplica",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "replicationState",
                "Enum": {
                  "new": [
                    [
                      "Active",
                      "Read replica is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "Read replica is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "Read replica is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "Read replica is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "Read replica is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ],
                  "old": [
                    [
                      "Active",
                      "The read replica server is fully synchronized and actively replicating data from the primary server."
                    ],
                    [
                      "Catchup",
                      "The read replica server is behind the primary server and is currently catching up with pending changes."
                    ],
                    [
                      "Provisioning",
                      "The read replica server is being created and is in process of getting initialized."
                    ],
                    [
                      "Updating",
                      "The read replica server is undergoing some changes it can be changing compute size of promoting it to primary server."
                    ],
                    [
                      "Broken",
                      "Replication has failed or been interrupted."
                    ],
                    [
                      "Reconfiguring",
                      "The read replica server is being reconfigured, possibly due to changes in source or settings."
                    ]
                  ]
                }
              }
            ]
          },
          {
            "#name": "createMode",
            "Enum": {
              "new": [
                [
                  "Default",
                  "If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'."
                ],
                [
                  "Create",
                  "Operation creates a new server."
                ],
                [
                  "Update",
                  "Operation updates an existing server."
                ],
                [
                  "PointInTimeRestore",
                  "Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time."
                ],
                [
                  "GeoRestore",
                  "Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled."
                ],
                [
                  "Replica",
                  "Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary."
                ],
                [
                  "ReviveDropped",
                  "Operation creates a new server, initialized with the backup of a server that was recently deleted."
                ]
              ],
              "old": [
                [
                  "Default",
                  ""
                ],
                [
                  "Create",
                  ""
                ],
                [
                  "Update",
                  ""
                ],
                [
                  "PointInTimeRestore",
                  ""
                ],
                [
                  "GeoRestore",
                  ""
                ],
                [
                  "Replica",
                  ""
                ],
                [
                  "ReviveDropped",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
}

⚐ Response (200)

{
sku:
{
name: string ,
tier: enum ,
}
,
identity:
{
userAssignedIdentities: object ,
principalId: string ,
type: enum ,
tenantId: string ,
}
,
properties:
{
administratorLogin: string ,
administratorLoginPassword: string ,
version: enum ,
minorVersion: string ,
state: enum ,
fullyQualifiedDomainName: string ,
storage:
{
storageSizeGB: integer ,
autoGrow: enum ,
tier: enum ,
iops: integer ,
throughput: integer ,
type: enum ,
}
,
authConfig:
{
activeDirectoryAuth: enum ,
passwordAuth: enum ,
tenantId: string ,
}
,
dataEncryption:
{
primaryKeyURI: string ,
primaryUserAssignedIdentityId: string ,
geoBackupKeyURI: string ,
geoBackupUserAssignedIdentityId: string ,
type: enum ,
primaryEncryptionKeyStatus: enum ,
geoBackupEncryptionKeyStatus: enum ,
}
,
backup:
{
backupRetentionDays: integer ,
geoRedundantBackup: enum ,
earliestRestoreDate: string ,
}
,
network:
{
publicNetworkAccess: enum ,
delegatedSubnetResourceId: string ,
privateDnsZoneArmResourceId: string ,
}
,
highAvailability:
{
mode: enum ,
state: enum ,
standbyAvailabilityZone: string ,
}
,
maintenanceWindow:
{
customWindow: string ,
startHour: integer ,
startMinute: integer ,
dayOfWeek: integer ,
}
,
sourceServerResourceId: string ,
pointInTimeUTC: string ,
availabilityZone: string ,
replicationRole: enum ,
replicaCapacity: integer ,
replica:
{
role: enum ,
capacity: integer ,
replicationState: enum ,
promoteMode: enum ,
promoteOption: enum ,
}
,
createMode: enum ,
privateEndpointConnections:
[
{
properties:
{
groupIds:
[
string ,
]
,
privateEndpoint:
{
id: string ,
}
,
privateLinkServiceConnectionState:
{
status: enum ,
description: string ,
actionsRequired: string ,
}
,
provisioningState: enum ,
}
,
}
,
]
,
cluster:
{
clusterSize: integer ,
defaultDatabaseName: string ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_ListByResourceGroup (updated)
Description Lists all servers in a resource group.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_ListByResourceGroup",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "sku": [
              {
                "#name": "tier",
                "Enum": {
                  "new": [
                    [
                      "Burstable",
                      "Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements."
                    ],
                    [
                      "GeneralPurpose",
                      "Balanced compute and memory for most workloads, offering scalable performance and I/O throughput."
                    ],
                    [
                      "MemoryOptimized",
                      "High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency."
                    ]
                  ],
                  "old": [
                    [
                      "Burstable",
                      ""
                    ],
                    [
                      "GeneralPurpose",
                      ""
                    ],
                    [
                      "MemoryOptimized",
                      ""
                    ]
                  ]
                }
              }
            ],
            "identity": [
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No managed identity is assigned to the server."
                    ],
                    [
                      "UserAssigned",
                      "One or more managed identities provided by the user are assigned to the server."
                    ],
                    [
                      "SystemAssigned",
                      "Azure automatically creates and manages the identity associated to the lifecycle of the server."
                    ],
                    [
                      "SystemAssigned,UserAssigned",
                      "Both system-assigned and user-assigned identities are assigned to the server."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "UserAssigned",
                      ""
                    ],
                    [
                      "SystemAssigned",
                      ""
                    ],
                    [
                      "SystemAssigned,UserAssigned",
                      ""
                    ]
                  ]
                }
              }
            ],
            "properties": [
              {
                "#name": "version",
                "Enum": {
                  "new": [
                    [
                      "17",
                      "PostgreSQL 17."
                    ],
                    [
                      "16",
                      "PostgreSQL 16."
                    ],
                    [
                      "15",
                      "PostgreSQL 15."
                    ],
                    [
                      "14",
                      "PostgreSQL 14."
                    ],
                    [
                      "13",
                      "PostgreSQL 13."
                    ],
                    [
                      "12",
                      "PostgreSQL 12."
                    ],
                    [
                      "11",
                      "PostgreSQL 11."
                    ]
                  ],
                  "old": [
                    [
                      "17",
                      ""
                    ],
                    [
                      "16",
                      ""
                    ],
                    [
                      "15",
                      ""
                    ],
                    [
                      "14",
                      ""
                    ],
                    [
                      "13",
                      ""
                    ],
                    [
                      "12",
                      ""
                    ],
                    [
                      "11",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "Ready",
                      "Server is healthy and not undergoing any operations at the management or control plane level. This doesn't mean that the server is fully operational at the data plane level."
                    ],
                    [
                      "Dropping",
                      "Server is being deleted."
                    ],
                    [
                      "Disabled",
                      "Server is disabled. Typical reasons include: the subscription on which the server is deployed is explicitly disabled or canceled by the administrator, the spending limit has been reached, or the bill is past due. May also happen when the server is being moved to another resource group or subscription."
                    ],
                    [
                      "Starting",
                      "PostgreSQL database engine is being restarted."
                    ],
                    [
                      "Stopping",
                      "Compute resources associated with the server are being stopped and deallocated. If the server has high availability enabled, the compute resources of the standby server are also stopped and deallocated."
                    ],
                    [
                      "Stopped",
                      "Compute resources associated with the server are being stopped and deallocated."
                    ],
                    [
                      "Updating",
                      "Server is undergoing some changes which may or may not impact the availability of the PostgreSQL database engine. For example, the compute resources of the server are being scaled up or down, which may cause temporary unavailability of the database engine. Or, for example, a firewall rule is being added or removed, which doesn't cause any unavailability of the database engine."
                    ],
                    [
                      "Restarting",
                      "PostgreSQL database engine is being restarted."
                    ],
                    [
                      "Inaccessible",
                      "Server isn't accessible, because the key provided to encrypt and decrypt the data is in invalid state."
                    ],
                    [
                      "Provisioning",
                      "Server is in the process of being created."
                    ]
                  ],
                  "old": [
                    [
                      "Ready",
                      ""
                    ],
                    [
                      "Dropping",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ],
                    [
                      "Starting",
                      ""
                    ],
                    [
                      "Stopping",
                      ""
                    ],
                    [
                      "Stopped",
                      ""
                    ],
                    [
                      "Updating",
                      ""
                    ],
                    [
                      "Restarting",
                      ""
                    ],
                    [
                      "Inaccessible",
                      ""
                    ],
                    [
                      "Provisioning",
                      ""
                    ]
                  ]
                }
              },
              {
                "storage": [
                  {
                    "#name": "autoGrow",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size."
                        ],
                        [
                          "Disabled",
                          "Server should not automatically grow storage size when available space is nearing zero."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "tier",
                    "Enum": {
                      "new": [
                        [
                          "P1",
                          "Entry-level SSD for minimal IOPS, ideal for light development or testing workloads."
                        ],
                        [
                          "P2",
                          "Slightly higher IOPS for small-scale applications needing consistent low latency."
                        ],
                        [
                          "P3",
                          "Balanced performance for basic production workloads with moderate throughput."
                        ],
                        [
                          "P4",
                          "Enhanced IOPS for growing apps with predictable performance needs."
                        ],
                        [
                          "P6",
                          "Mid-tier SSD for steady workloads requiring reliable throughput and latency."
                        ],
                        [
                          "P10",
                          "Popular choice for general-purpose production workloads with scalable performance."
                        ],
                        [
                          "P15",
                          "High IOPS tier for demanding apps with frequent read/write operations."
                        ],
                        [
                          "P20",
                          "Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads."
                        ],
                        [
                          "P30",
                          "Balanced tier for moderate throughput and latency-sensitive applications."
                        ],
                        [
                          "P40",
                          "Enhanced performance for growing production workloads with consistent IOPS demands."
                        ],
                        [
                          "P50",
                          "Optimized for enterprise-grade applications needing sustained high throughput."
                        ],
                        [
                          "P60",
                          "High-capacity tier for large databases and analytics workloads with elevated IOPS."
                        ],
                        [
                          "P70",
                          "Designed for mission-critical systems requiring ultra-low latency and high concurrency."
                        ],
                        [
                          "P80",
                          "Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads."
                        ]
                      ],
                      "old": [
                        [
                          "P1",
                          ""
                        ],
                        [
                          "P2",
                          ""
                        ],
                        [
                          "P3",
                          ""
                        ],
                        [
                          "P4",
                          ""
                        ],
                        [
                          "P6",
                          ""
                        ],
                        [
                          "P10",
                          ""
                        ],
                        [
                          "P15",
                          ""
                        ],
                        [
                          "P20",
                          ""
                        ],
                        [
                          "P30",
                          ""
                        ],
                        [
                          "P40",
                          ""
                        ],
                        [
                          "P50",
                          ""
                        ],
                        [
                          "P60",
                          ""
                        ],
                        [
                          "P70",
                          ""
                        ],
                        [
                          "P80",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "type",
                    "Enum": {
                      "new": [
                        [
                          "Premium_LRS",
                          "Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads."
                        ],
                        [
                          "PremiumV2_LRS",
                          "Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads."
                        ],
                        [
                          "UltraSSD_LRS",
                          "High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications."
                        ]
                      ],
                      "old": [
                        [
                          "Premium_LRS",
                          ""
                        ],
                        [
                          "PremiumV2_LRS",
                          ""
                        ],
                        [
                          "UltraSSD_LRS",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "authConfig": [
                  {
                    "#name": "activeDirectoryAuth",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server supports Microsoft Entra authentication."
                        ],
                        [
                          "Disabled",
                          "Server doesn't support Microsoft Entra authentication."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "passwordAuth",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server supports password based authentication."
                        ],
                        [
                          "Disabled",
                          "Server doesn't support password based authentication."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "dataEncryption": [
                  {
                    "#name": "type",
                    "Enum": {
                      "new": [
                        [
                          "SystemManaged",
                          "Encryption managed by Azure using platform managed keys for simplicity and compliance."
                        ],
                        [
                          "AzureKeyVault",
                          "Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security."
                        ]
                      ],
                      "old": [
                        [
                          "SystemManaged",
                          ""
                        ],
                        [
                          "AzureKeyVault",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "primaryEncryptionKeyStatus",
                    "Enum": {
                      "new": [
                        [
                          "Valid",
                          "Key is valid and can be used for encryption."
                        ],
                        [
                          "Invalid",
                          "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                        ]
                      ],
                      "old": [
                        [
                          "Valid",
                          ""
                        ],
                        [
                          "Invalid",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "geoBackupEncryptionKeyStatus",
                    "Enum": {
                      "new": [
                        [
                          "Valid",
                          "Key is valid and can be used for encryption."
                        ],
                        [
                          "Invalid",
                          "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                        ]
                      ],
                      "old": [
                        [
                          "Valid",
                          ""
                        ],
                        [
                          "Invalid",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "backup": [
                  {
                    "#name": "geoRedundantBackup",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server is configured to create geographically redundant backups."
                        ],
                        [
                          "Disabled",
                          "Server is not configured to create geographically redundant backups."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "network": [
                  {
                    "#name": "publicNetworkAccess",
                    "Description": {
                      "new": "Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed.",
                      "old": "Indicates if public network access is enabled or not."
                    },
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server."
                        ],
                        [
                          "Disabled",
                          "Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "highAvailability": [
                  {
                    "#name": "mode",
                    "Enum": {
                      "new": [
                        [
                          "Disabled",
                          "High availability is disabled for the server."
                        ],
                        [
                          "ZoneRedundant",
                          "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                        ],
                        [
                          "SameZone",
                          "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                        ]
                      ],
                      "old": [
                        [
                          "Disabled",
                          ""
                        ],
                        [
                          "ZoneRedundant",
                          ""
                        ],
                        [
                          "SameZone",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "state",
                    "Enum": {
                      "new": [
                        [
                          "NotEnabled",
                          "High availability is not enabled for the server."
                        ],
                        [
                          "CreatingStandby",
                          "Standby server is being created."
                        ],
                        [
                          "ReplicatingData",
                          "Data is being replicated to the standby server."
                        ],
                        [
                          "FailingOver",
                          "Failover operation to the standby server is in progress."
                        ],
                        [
                          "Healthy",
                          "Standby server is healthy and ready to take over in case of a failover."
                        ],
                        [
                          "RemovingStandby",
                          "Standby server is being removed."
                        ]
                      ],
                      "old": [
                        [
                          "NotEnabled",
                          ""
                        ],
                        [
                          "CreatingStandby",
                          ""
                        ],
                        [
                          "ReplicatingData",
                          ""
                        ],
                        [
                          "FailingOver",
                          ""
                        ],
                        [
                          "Healthy",
                          ""
                        ],
                        [
                          "RemovingStandby",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "#name": "replicationRole",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No replication role assigned; the server operates independently."
                    ],
                    [
                      "Primary",
                      "Acts as the source server for replication to one or more replicas."
                    ],
                    [
                      "AsyncReplica",
                      "Receives data asynchronously from a primary server within the same region."
                    ],
                    [
                      "GeoAsyncReplica",
                      "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "Primary",
                      ""
                    ],
                    [
                      "AsyncReplica",
                      ""
                    ],
                    [
                      "GeoAsyncReplica",
                      ""
                    ]
                  ]
                }
              },
              {
                "replica": [
                  {
                    "#name": "role",
                    "Enum": {
                      "new": [
                        [
                          "None",
                          "No replication role assigned; the server operates independently."
                        ],
                        [
                          "Primary",
                          "Acts as the source server for replication to one or more replicas."
                        ],
                        [
                          "AsyncReplica",
                          "Receives data asynchronously from a primary server within the same region."
                        ],
                        [
                          "GeoAsyncReplica",
                          "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                        ]
                      ],
                      "old": [
                        [
                          "None",
                          ""
                        ],
                        [
                          "Primary",
                          ""
                        ],
                        [
                          "AsyncReplica",
                          ""
                        ],
                        [
                          "GeoAsyncReplica",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "replicationState",
                    "Enum": {
                      "new": [
                        [
                          "Active",
                          "Read replica is fully synchronized and actively replicating data from the primary server."
                        ],
                        [
                          "Catchup",
                          "Read replica is behind the primary server and is currently catching up with pending changes."
                        ],
                        [
                          "Provisioning",
                          "Read replica is being created and is in process of getting initialized."
                        ],
                        [
                          "Updating",
                          "Read replica is undergoing some changes it can be changing compute size of promoting it to primary server."
                        ],
                        [
                          "Broken",
                          "Replication has failed or been interrupted."
                        ],
                        [
                          "Reconfiguring",
                          "Read replica is being reconfigured, possibly due to changes in source or settings."
                        ]
                      ],
                      "old": [
                        [
                          "Active",
                          "The read replica server is fully synchronized and actively replicating data from the primary server."
                        ],
                        [
                          "Catchup",
                          "The read replica server is behind the primary server and is currently catching up with pending changes."
                        ],
                        [
                          "Provisioning",
                          "The read replica server is being created and is in process of getting initialized."
                        ],
                        [
                          "Updating",
                          "The read replica server is undergoing some changes it can be changing compute size of promoting it to primary server."
                        ],
                        [
                          "Broken",
                          "Replication has failed or been interrupted."
                        ],
                        [
                          "Reconfiguring",
                          "The read replica server is being reconfigured, possibly due to changes in source or settings."
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "#name": "createMode",
                "Enum": {
                  "new": [
                    [
                      "Default",
                      "If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'."
                    ],
                    [
                      "Create",
                      "Operation creates a new server."
                    ],
                    [
                      "Update",
                      "Operation updates an existing server."
                    ],
                    [
                      "PointInTimeRestore",
                      "Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time."
                    ],
                    [
                      "GeoRestore",
                      "Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled."
                    ],
                    [
                      "Replica",
                      "Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary."
                    ],
                    [
                      "ReviveDropped",
                      "Operation creates a new server, initialized with the backup of a server that was recently deleted."
                    ]
                  ],
                  "old": [
                    [
                      "Default",
                      ""
                    ],
                    [
                      "Create",
                      ""
                    ],
                    [
                      "Update",
                      ""
                    ],
                    [
                      "PointInTimeRestore",
                      ""
                    ],
                    [
                      "GeoRestore",
                      ""
                    ],
                    [
                      "Replica",
                      ""
                    ],
                    [
                      "ReviveDropped",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
}

⚐ Response (200)

{
value:
[
{
sku:
{
name: string ,
tier: enum ,
}
,
identity:
{
userAssignedIdentities: object ,
principalId: string ,
type: enum ,
tenantId: string ,
}
,
properties:
{
administratorLogin: string ,
administratorLoginPassword: string ,
version: enum ,
minorVersion: string ,
state: enum ,
fullyQualifiedDomainName: string ,
storage:
{
storageSizeGB: integer ,
autoGrow: enum ,
tier: enum ,
iops: integer ,
throughput: integer ,
type: enum ,
}
,
authConfig:
{
activeDirectoryAuth: enum ,
passwordAuth: enum ,
tenantId: string ,
}
,
dataEncryption:
{
primaryKeyURI: string ,
primaryUserAssignedIdentityId: string ,
geoBackupKeyURI: string ,
geoBackupUserAssignedIdentityId: string ,
type: enum ,
primaryEncryptionKeyStatus: enum ,
geoBackupEncryptionKeyStatus: enum ,
}
,
backup:
{
backupRetentionDays: integer ,
geoRedundantBackup: enum ,
earliestRestoreDate: string ,
}
,
network:
{
publicNetworkAccess: enum ,
delegatedSubnetResourceId: string ,
privateDnsZoneArmResourceId: string ,
}
,
highAvailability:
{
mode: enum ,
state: enum ,
standbyAvailabilityZone: string ,
}
,
maintenanceWindow:
{
customWindow: string ,
startHour: integer ,
startMinute: integer ,
dayOfWeek: integer ,
}
,
sourceServerResourceId: string ,
pointInTimeUTC: string ,
availabilityZone: string ,
replicationRole: enum ,
replicaCapacity: integer ,
replica:
{
role: enum ,
capacity: integer ,
replicationState: enum ,
promoteMode: enum ,
promoteOption: enum ,
}
,
createMode: enum ,
privateEndpointConnections:
[
{
properties:
{
groupIds:
[
string ,
]
,
privateEndpoint:
{
id: string ,
}
,
privateLinkServiceConnectionState:
{
status: enum ,
description: string ,
actionsRequired: string ,
}
,
provisioningState: enum ,
}
,
}
,
]
,
cluster:
{
clusterSize: integer ,
defaultDatabaseName: string ,
}
,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_ListBySubscription (updated)
Description Lists all servers in a subscription.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_ListBySubscription",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "sku": [
              {
                "#name": "tier",
                "Enum": {
                  "new": [
                    [
                      "Burstable",
                      "Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements."
                    ],
                    [
                      "GeneralPurpose",
                      "Balanced compute and memory for most workloads, offering scalable performance and I/O throughput."
                    ],
                    [
                      "MemoryOptimized",
                      "High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency."
                    ]
                  ],
                  "old": [
                    [
                      "Burstable",
                      ""
                    ],
                    [
                      "GeneralPurpose",
                      ""
                    ],
                    [
                      "MemoryOptimized",
                      ""
                    ]
                  ]
                }
              }
            ],
            "identity": [
              {
                "#name": "type",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No managed identity is assigned to the server."
                    ],
                    [
                      "UserAssigned",
                      "One or more managed identities provided by the user are assigned to the server."
                    ],
                    [
                      "SystemAssigned",
                      "Azure automatically creates and manages the identity associated to the lifecycle of the server."
                    ],
                    [
                      "SystemAssigned,UserAssigned",
                      "Both system-assigned and user-assigned identities are assigned to the server."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "UserAssigned",
                      ""
                    ],
                    [
                      "SystemAssigned",
                      ""
                    ],
                    [
                      "SystemAssigned,UserAssigned",
                      ""
                    ]
                  ]
                }
              }
            ],
            "properties": [
              {
                "#name": "version",
                "Enum": {
                  "new": [
                    [
                      "17",
                      "PostgreSQL 17."
                    ],
                    [
                      "16",
                      "PostgreSQL 16."
                    ],
                    [
                      "15",
                      "PostgreSQL 15."
                    ],
                    [
                      "14",
                      "PostgreSQL 14."
                    ],
                    [
                      "13",
                      "PostgreSQL 13."
                    ],
                    [
                      "12",
                      "PostgreSQL 12."
                    ],
                    [
                      "11",
                      "PostgreSQL 11."
                    ]
                  ],
                  "old": [
                    [
                      "17",
                      ""
                    ],
                    [
                      "16",
                      ""
                    ],
                    [
                      "15",
                      ""
                    ],
                    [
                      "14",
                      ""
                    ],
                    [
                      "13",
                      ""
                    ],
                    [
                      "12",
                      ""
                    ],
                    [
                      "11",
                      ""
                    ]
                  ]
                }
              },
              {
                "#name": "state",
                "Enum": {
                  "new": [
                    [
                      "Ready",
                      "Server is healthy and not undergoing any operations at the management or control plane level. This doesn't mean that the server is fully operational at the data plane level."
                    ],
                    [
                      "Dropping",
                      "Server is being deleted."
                    ],
                    [
                      "Disabled",
                      "Server is disabled. Typical reasons include: the subscription on which the server is deployed is explicitly disabled or canceled by the administrator, the spending limit has been reached, or the bill is past due. May also happen when the server is being moved to another resource group or subscription."
                    ],
                    [
                      "Starting",
                      "PostgreSQL database engine is being restarted."
                    ],
                    [
                      "Stopping",
                      "Compute resources associated with the server are being stopped and deallocated. If the server has high availability enabled, the compute resources of the standby server are also stopped and deallocated."
                    ],
                    [
                      "Stopped",
                      "Compute resources associated with the server are being stopped and deallocated."
                    ],
                    [
                      "Updating",
                      "Server is undergoing some changes which may or may not impact the availability of the PostgreSQL database engine. For example, the compute resources of the server are being scaled up or down, which may cause temporary unavailability of the database engine. Or, for example, a firewall rule is being added or removed, which doesn't cause any unavailability of the database engine."
                    ],
                    [
                      "Restarting",
                      "PostgreSQL database engine is being restarted."
                    ],
                    [
                      "Inaccessible",
                      "Server isn't accessible, because the key provided to encrypt and decrypt the data is in invalid state."
                    ],
                    [
                      "Provisioning",
                      "Server is in the process of being created."
                    ]
                  ],
                  "old": [
                    [
                      "Ready",
                      ""
                    ],
                    [
                      "Dropping",
                      ""
                    ],
                    [
                      "Disabled",
                      ""
                    ],
                    [
                      "Starting",
                      ""
                    ],
                    [
                      "Stopping",
                      ""
                    ],
                    [
                      "Stopped",
                      ""
                    ],
                    [
                      "Updating",
                      ""
                    ],
                    [
                      "Restarting",
                      ""
                    ],
                    [
                      "Inaccessible",
                      ""
                    ],
                    [
                      "Provisioning",
                      ""
                    ]
                  ]
                }
              },
              {
                "storage": [
                  {
                    "#name": "autoGrow",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size."
                        ],
                        [
                          "Disabled",
                          "Server should not automatically grow storage size when available space is nearing zero."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "tier",
                    "Enum": {
                      "new": [
                        [
                          "P1",
                          "Entry-level SSD for minimal IOPS, ideal for light development or testing workloads."
                        ],
                        [
                          "P2",
                          "Slightly higher IOPS for small-scale applications needing consistent low latency."
                        ],
                        [
                          "P3",
                          "Balanced performance for basic production workloads with moderate throughput."
                        ],
                        [
                          "P4",
                          "Enhanced IOPS for growing apps with predictable performance needs."
                        ],
                        [
                          "P6",
                          "Mid-tier SSD for steady workloads requiring reliable throughput and latency."
                        ],
                        [
                          "P10",
                          "Popular choice for general-purpose production workloads with scalable performance."
                        ],
                        [
                          "P15",
                          "High IOPS tier for demanding apps with frequent read/write operations."
                        ],
                        [
                          "P20",
                          "Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads."
                        ],
                        [
                          "P30",
                          "Balanced tier for moderate throughput and latency-sensitive applications."
                        ],
                        [
                          "P40",
                          "Enhanced performance for growing production workloads with consistent IOPS demands."
                        ],
                        [
                          "P50",
                          "Optimized for enterprise-grade applications needing sustained high throughput."
                        ],
                        [
                          "P60",
                          "High-capacity tier for large databases and analytics workloads with elevated IOPS."
                        ],
                        [
                          "P70",
                          "Designed for mission-critical systems requiring ultra-low latency and high concurrency."
                        ],
                        [
                          "P80",
                          "Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads."
                        ]
                      ],
                      "old": [
                        [
                          "P1",
                          ""
                        ],
                        [
                          "P2",
                          ""
                        ],
                        [
                          "P3",
                          ""
                        ],
                        [
                          "P4",
                          ""
                        ],
                        [
                          "P6",
                          ""
                        ],
                        [
                          "P10",
                          ""
                        ],
                        [
                          "P15",
                          ""
                        ],
                        [
                          "P20",
                          ""
                        ],
                        [
                          "P30",
                          ""
                        ],
                        [
                          "P40",
                          ""
                        ],
                        [
                          "P50",
                          ""
                        ],
                        [
                          "P60",
                          ""
                        ],
                        [
                          "P70",
                          ""
                        ],
                        [
                          "P80",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "type",
                    "Enum": {
                      "new": [
                        [
                          "Premium_LRS",
                          "Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads."
                        ],
                        [
                          "PremiumV2_LRS",
                          "Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads."
                        ],
                        [
                          "UltraSSD_LRS",
                          "High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications."
                        ]
                      ],
                      "old": [
                        [
                          "Premium_LRS",
                          ""
                        ],
                        [
                          "PremiumV2_LRS",
                          ""
                        ],
                        [
                          "UltraSSD_LRS",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "authConfig": [
                  {
                    "#name": "activeDirectoryAuth",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server supports Microsoft Entra authentication."
                        ],
                        [
                          "Disabled",
                          "Server doesn't support Microsoft Entra authentication."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "passwordAuth",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server supports password based authentication."
                        ],
                        [
                          "Disabled",
                          "Server doesn't support password based authentication."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "dataEncryption": [
                  {
                    "#name": "type",
                    "Enum": {
                      "new": [
                        [
                          "SystemManaged",
                          "Encryption managed by Azure using platform managed keys for simplicity and compliance."
                        ],
                        [
                          "AzureKeyVault",
                          "Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security."
                        ]
                      ],
                      "old": [
                        [
                          "SystemManaged",
                          ""
                        ],
                        [
                          "AzureKeyVault",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "primaryEncryptionKeyStatus",
                    "Enum": {
                      "new": [
                        [
                          "Valid",
                          "Key is valid and can be used for encryption."
                        ],
                        [
                          "Invalid",
                          "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                        ]
                      ],
                      "old": [
                        [
                          "Valid",
                          ""
                        ],
                        [
                          "Invalid",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "geoBackupEncryptionKeyStatus",
                    "Enum": {
                      "new": [
                        [
                          "Valid",
                          "Key is valid and can be used for encryption."
                        ],
                        [
                          "Invalid",
                          "Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key."
                        ]
                      ],
                      "old": [
                        [
                          "Valid",
                          ""
                        ],
                        [
                          "Invalid",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "backup": [
                  {
                    "#name": "geoRedundantBackup",
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Server is configured to create geographically redundant backups."
                        ],
                        [
                          "Disabled",
                          "Server is not configured to create geographically redundant backups."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "network": [
                  {
                    "#name": "publicNetworkAccess",
                    "Description": {
                      "new": "Indicates if public network access is enabled or not. This is only supported for servers that are not integrated into a virtual network which is owned and provided by customer when server is deployed.",
                      "old": "Indicates if public network access is enabled or not."
                    },
                    "Enum": {
                      "new": [
                        [
                          "Enabled",
                          "Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server."
                        ],
                        [
                          "Disabled",
                          "Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints."
                        ]
                      ],
                      "old": [
                        [
                          "Enabled",
                          ""
                        ],
                        [
                          "Disabled",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "highAvailability": [
                  {
                    "#name": "mode",
                    "Enum": {
                      "new": [
                        [
                          "Disabled",
                          "High availability is disabled for the server."
                        ],
                        [
                          "ZoneRedundant",
                          "High availability is enabled for the server, with standby server in a different availability zone than that of the primary."
                        ],
                        [
                          "SameZone",
                          "High availability is enabled for the server, with standby server in the same availability zone as the primary."
                        ]
                      ],
                      "old": [
                        [
                          "Disabled",
                          ""
                        ],
                        [
                          "ZoneRedundant",
                          ""
                        ],
                        [
                          "SameZone",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "state",
                    "Enum": {
                      "new": [
                        [
                          "NotEnabled",
                          "High availability is not enabled for the server."
                        ],
                        [
                          "CreatingStandby",
                          "Standby server is being created."
                        ],
                        [
                          "ReplicatingData",
                          "Data is being replicated to the standby server."
                        ],
                        [
                          "FailingOver",
                          "Failover operation to the standby server is in progress."
                        ],
                        [
                          "Healthy",
                          "Standby server is healthy and ready to take over in case of a failover."
                        ],
                        [
                          "RemovingStandby",
                          "Standby server is being removed."
                        ]
                      ],
                      "old": [
                        [
                          "NotEnabled",
                          ""
                        ],
                        [
                          "CreatingStandby",
                          ""
                        ],
                        [
                          "ReplicatingData",
                          ""
                        ],
                        [
                          "FailingOver",
                          ""
                        ],
                        [
                          "Healthy",
                          ""
                        ],
                        [
                          "RemovingStandby",
                          ""
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "#name": "replicationRole",
                "Enum": {
                  "new": [
                    [
                      "None",
                      "No replication role assigned; the server operates independently."
                    ],
                    [
                      "Primary",
                      "Acts as the source server for replication to one or more replicas."
                    ],
                    [
                      "AsyncReplica",
                      "Receives data asynchronously from a primary server within the same region."
                    ],
                    [
                      "GeoAsyncReplica",
                      "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                    ]
                  ],
                  "old": [
                    [
                      "None",
                      ""
                    ],
                    [
                      "Primary",
                      ""
                    ],
                    [
                      "AsyncReplica",
                      ""
                    ],
                    [
                      "GeoAsyncReplica",
                      ""
                    ]
                  ]
                }
              },
              {
                "replica": [
                  {
                    "#name": "role",
                    "Enum": {
                      "new": [
                        [
                          "None",
                          "No replication role assigned; the server operates independently."
                        ],
                        [
                          "Primary",
                          "Acts as the source server for replication to one or more replicas."
                        ],
                        [
                          "AsyncReplica",
                          "Receives data asynchronously from a primary server within the same region."
                        ],
                        [
                          "GeoAsyncReplica",
                          "Receives data asynchronously from a primary server in a different region for geographical redundancy."
                        ]
                      ],
                      "old": [
                        [
                          "None",
                          ""
                        ],
                        [
                          "Primary",
                          ""
                        ],
                        [
                          "AsyncReplica",
                          ""
                        ],
                        [
                          "GeoAsyncReplica",
                          ""
                        ]
                      ]
                    }
                  },
                  {
                    "#name": "replicationState",
                    "Enum": {
                      "new": [
                        [
                          "Active",
                          "Read replica is fully synchronized and actively replicating data from the primary server."
                        ],
                        [
                          "Catchup",
                          "Read replica is behind the primary server and is currently catching up with pending changes."
                        ],
                        [
                          "Provisioning",
                          "Read replica is being created and is in process of getting initialized."
                        ],
                        [
                          "Updating",
                          "Read replica is undergoing some changes it can be changing compute size of promoting it to primary server."
                        ],
                        [
                          "Broken",
                          "Replication has failed or been interrupted."
                        ],
                        [
                          "Reconfiguring",
                          "Read replica is being reconfigured, possibly due to changes in source or settings."
                        ]
                      ],
                      "old": [
                        [
                          "Active",
                          "The read replica server is fully synchronized and actively replicating data from the primary server."
                        ],
                        [
                          "Catchup",
                          "The read replica server is behind the primary server and is currently catching up with pending changes."
                        ],
                        [
                          "Provisioning",
                          "The read replica server is being created and is in process of getting initialized."
                        ],
                        [
                          "Updating",
                          "The read replica server is undergoing some changes it can be changing compute size of promoting it to primary server."
                        ],
                        [
                          "Broken",
                          "Replication has failed or been interrupted."
                        ],
                        [
                          "Reconfiguring",
                          "The read replica server is being reconfigured, possibly due to changes in source or settings."
                        ]
                      ]
                    }
                  }
                ]
              },
              {
                "#name": "createMode",
                "Enum": {
                  "new": [
                    [
                      "Default",
                      "If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'."
                    ],
                    [
                      "Create",
                      "Operation creates a new server."
                    ],
                    [
                      "Update",
                      "Operation updates an existing server."
                    ],
                    [
                      "PointInTimeRestore",
                      "Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time."
                    ],
                    [
                      "GeoRestore",
                      "Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled."
                    ],
                    [
                      "Replica",
                      "Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary."
                    ],
                    [
                      "ReviveDropped",
                      "Operation creates a new server, initialized with the backup of a server that was recently deleted."
                    ]
                  ],
                  "old": [
                    [
                      "Default",
                      ""
                    ],
                    [
                      "Create",
                      ""
                    ],
                    [
                      "Update",
                      ""
                    ],
                    [
                      "PointInTimeRestore",
                      ""
                    ],
                    [
                      "GeoRestore",
                      ""
                    ],
                    [
                      "Replica",
                      ""
                    ],
                    [
                      "ReviveDropped",
                      ""
                    ]
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/providers/Microsoft.DBforPostgreSQL/flexibleServers
{
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
value:
[
{
sku:
{
name: string ,
tier: enum ,
}
,
identity:
{
userAssignedIdentities: object ,
principalId: string ,
type: enum ,
tenantId: string ,
}
,
properties:
{
administratorLogin: string ,
administratorLoginPassword: string ,
version: enum ,
minorVersion: string ,
state: enum ,
fullyQualifiedDomainName: string ,
storage:
{
storageSizeGB: integer ,
autoGrow: enum ,
tier: enum ,
iops: integer ,
throughput: integer ,
type: enum ,
}
,
authConfig:
{
activeDirectoryAuth: enum ,
passwordAuth: enum ,
tenantId: string ,
}
,
dataEncryption:
{
primaryKeyURI: string ,
primaryUserAssignedIdentityId: string ,
geoBackupKeyURI: string ,
geoBackupUserAssignedIdentityId: string ,
type: enum ,
primaryEncryptionKeyStatus: enum ,
geoBackupEncryptionKeyStatus: enum ,
}
,
backup:
{
backupRetentionDays: integer ,
geoRedundantBackup: enum ,
earliestRestoreDate: string ,
}
,
network:
{
publicNetworkAccess: enum ,
delegatedSubnetResourceId: string ,
privateDnsZoneArmResourceId: string ,
}
,
highAvailability:
{
mode: enum ,
state: enum ,
standbyAvailabilityZone: string ,
}
,
maintenanceWindow:
{
customWindow: string ,
startHour: integer ,
startMinute: integer ,
dayOfWeek: integer ,
}
,
sourceServerResourceId: string ,
pointInTimeUTC: string ,
availabilityZone: string ,
replicationRole: enum ,
replicaCapacity: integer ,
replica:
{
role: enum ,
capacity: integer ,
replicationState: enum ,
promoteMode: enum ,
promoteOption: enum ,
}
,
createMode: enum ,
privateEndpointConnections:
[
{
properties:
{
groupIds:
[
string ,
]
,
privateEndpoint:
{
id: string ,
}
,
privateLinkServiceConnectionState:
{
status: enum ,
description: string ,
actionsRequired: string ,
}
,
provisioningState: enum ,
}
,
}
,
]
,
cluster:
{
clusterSize: integer ,
defaultDatabaseName: string ,
}
,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
Servers_Restart (updated)
Description Restarts PostgreSQL database engine in a server.
Reference Link ¶

⚶ Changes

{
  "#id": "Servers_Restart",
  "$parameters": {
    "parameters": {
      "$properties": [
        {
          "#name": "failoverMode",
          "Enum": {
            "new": [
              [
                "PlannedFailover",
                "Triggers a failover from primary to standby without killing the primary database process first. This is a graceful failover that attempts to preserve data consistency."
              ],
              [
                "ForcedFailover",
                "Kills the primary database process first, then triggers the failover. This is more aggressive and used when the primary is unresponsive or in an unhealthy state."
              ],
              [
                "PlannedSwitchover",
                "Similar to 'PlannedFailover' but prefers a switch over operation where roles are swapped between primary and standby."
              ],
              [
                "ForcedSwitchover",
                "Kills the primary database process and then triggers a switch over with role swapping."
              ]
            ],
            "old": [
              [
                "PlannedFailover",
                ""
              ],
              [
                "ForcedFailover",
                ""
              ],
              [
                "PlannedSwitchover",
                ""
              ],
              [
                "ForcedSwitchover",
                ""
              ]
            ]
          }
        }
      ]
    }
  }
}

⚼ Request

POST:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/restart
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
parameters:
{
restartWithFailover: boolean ,
failoverMode: enum ,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}
VirtualEndpoints_Update (updated)
Description Updates a pair of virtual endpoints for a server.
Reference Link ¶

⚶ Changes

{
  "#id": "VirtualEndpoints_Update",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "#name": "endpointType",
            "Enum": {
              "new": [
                [
                  "ReadWrite",
                  "Read-write endpoint."
                ]
              ],
              "old": [
                [
                  "ReadWrite",
                  ""
                ]
              ]
            }
          }
        ]
      }
    }
  }
}

⚼ Request

PATCH:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/virtualendpoints/{virtualEndpointName}
{
api-version: string ,
subscriptionId: string ,
resourceGroupName: string ,
serverName: string ,
virtualEndpointName: string ,
parameters:
{
properties:
{
endpointType: enum ,
members:
[
string ,
]
,
virtualEndpoints:
[
string ,
]
,
}
,
}
,
}

⚐ Response (202)

{
location: string ,
azure-asyncoperation: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
additionalInfo:
[
{
type: string ,
info: object ,
}
,
]
,
}
,
}