Skapa en Azure Database for PostgreSQL-instans med hjälp av .NET SDK

I den här snabbstarten lär du dig hur du använder Azure SDKs-biblioteken i .NET för att skapa, uppdatera och ta bort en flexibel Azure PostgreSQL-serverinstans. Azure Database for PostgreSQL är en hanterad tjänst som gör att du kan köra, hantera och skala PostgreSQL-databaser med hög tillgänglighet i molnet. Med hjälp av .NET SDK kan du etablera en flexibel Serverinstans för Azure Database for PostgreSQL, flera servrar eller flera databaser på en server.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration.
Snabbstart: Skapa en flexibel serverinstans för Azure Database for PostgreSQL.
.NET Framework installerat på den lokala datorn.
Azure CLI installerat på din lokala dator.

Azure.ResourceManager.PostgreSql-bibliotek

Biblioteket Azure.ResourceManager.PostgreSql är en del av Azure SDKs för .NET och tillhandahåller funktioner för att hantera flexibla PostgreSQL-serverinstanser i Azure. Med det här biblioteket kan du utföra olika åtgärder relaterade till flexibla PostgreSQL-serverinstanser, inklusive men inte begränsat till:

Skapa flexibla Azure PostgreSQL-serverinstanser:
Du kan skapa nya flexibla serverinstanser med angivna konfigurationer som plats, SKU, lagring och version.
Uppdatera flexibla Azure PostgreSQL-serverinstanser:
Du kan uppdatera befintliga flexibla PostgreSQL-serverinstanser, inklusive att ändra konfigurationer som administratörsinloggning, lösenord, SKU, lagring och version.
Ta bort flexibla Azure PostgreSQL-serverinstanser:
Du kan ta bort befintliga flexibla Azure PostgreSQL-serverinstanser.
Hämtar Azure PostgreSQL-information:
Du kan hämta information om befintliga flexibla PostgreSQL-serverinstanser, inklusive deras konfigurationer, status och andra metadata.
Hantera databaser:
Du kan skapa, uppdatera, ta bort och hämta databaser i den flexibla Azure PostgreSQL-serverinstansen.
Hantera brandväggsregler:
Du kan skapa, uppdatera, ta bort och hämta brandväggsregler för en instans för att styra åtkomsten.
Hantera konfigurationsinställningar:
Du kan hantera konfigurationsinställningar för en Azure flexibel PostgreSQL-serverinstans, inklusive hämtning och uppdatering av parametrar.

Logga in på Azure

Innan du använder Azure SDKs för .NET för att skapa, uppdatera eller ta bort en flexibel Azure Database for PostgreSQL-serverinstans måste du logga in på ditt Azure-konto med hjälp av Azure CLI.

Logga in på ditt konto med az CLI

az login

Installera de paket som krävs

Installera nödvändiga paket med hjälp av följande kommandon:

dotnet add package Azure.Identity
dotnet add package Azure.ResourceManager
dotnet add package Azure.ResourceManager.PostgreSql

När du har installerat dessa paket, kontrollerar du att varje em visas i .csproj-filen innan du kör kommandona build och run.

Mer information om filen finns i .csproj Webbdistribution.

Note

Om du har problem som rör den första installationen för .NET följer du den här guiden.

Skapa projektet

Skapa ett nytt .NET-projekt genom att följa stegen i den här länken

Skapa servern

Skapa en flexibel PostgreSQL-serverinstans genom att skapa en fil med namnet CreateServer.cs med följande kod.

using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql.FlexibleServers;
using Azure.ResourceManager.PostgreSql.FlexibleServers.Models;

namespace CreatePostgreSqlFlexibleServer
{
    class Program
 {
        static async Task Main(string[] args)
   {

            TokenCredential credential = new DefaultAzureCredential();
            ArmClient armClient = new ArmClient(credential);
            // Replace with your subscription ID
            string subscriptionId = "subscription-id";
            // Replace with your resource group name
            string resourceGroupName = "resource-group-name";
           // Replace with a unique server name
            string serverName = "server-name";
           // Replace with your desired region
            string location = "region-name";
          // Create the resource identifier for the resource group
            ResourceIdentifier resourceGroupId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
            ResourceGroupResource resourceGroup = await armClient.GetResourceGroupResource(resourceGroupId).GetAsync();
            // Prepare server data
            var serverData = new PostgreSqlFlexibleServerData(location)
            {
              AdministratorLogin = "admin-username",
              AdministratorLoginPassword = "<admin-password>",
              Version = "pgVersion",
              Storage = new PostgreSqlFlexibleServerStorage() { StorageSizeInGB = 128 },
              Sku = new PostgreSqlFlexibleServerSku("Standard_B1ms", PostgreSqlFlexibleServerSkuTier.Burstable),
           };
            try
            {
               ArmOperation<PostgreSqlFlexibleServerResource> operation = await resourceGroup.GetPostgreSqlFlexibleServers().CreateOrUpdateAsync(Azure.WaitUntil.Completed, serverName, serverData);
              PostgreSqlFlexibleServerResource serverResource = operation.Value;
              Console.WriteLine($"PostgreSQL flexible server '{serverResource.Data.Name}' created successfully.");
           }
            catch (Exception ex)
            {
               Console.WriteLine($"An error occurred: {ex.Message}");
            }
   }
  }
}

Det här exemplet visar hur du skapar en flexibel PostgreSQL-serverinstans med hjälp av Azure Resource Manager. PostgreSql-bibliotek. Du kan på samma sätt använda andra metoder som tillhandahålls av biblioteket för att hantera dina flexibla PostgreSQL-serverinstanser och relaterade resurser.

Ersätt följande parametrar i koden med dina data:

subscription-id: ID:t för din Azure-prenumeration.
resource-group-name: Namnet på resursgruppen.
server-name: Ett unikt namn för PostgreSQL-servern.
location: Azure-regionen för servern.
admin-username: Administratörens användarnamn.
admin-password: Administratörslösenordet.
pgVersion: PostgreSQL-versionen (till exempel 11, 12, 13, 14, 15 eller 16).

Authentication

Klassen försöker autentisera DefaultAzureCredential med metoder som miljövariabler, hanterade identiteter eller Azure CLI. Se till att någon av dessa metoder har konfigurerats.

Kör filen

Om du vill köra filen måste du skapa och köra .cs-filen med hjälp av .NET CLI. Detta initierar processen för att skapa, uppdatera eller ta bort PostgreSQL-instansen enligt koden.

Varje gång du gör någon ändring i .cs-filen ska du inte glömma att skapa och sedan köra filen

Kör filen .cs med kommandona nedan

dotnet build
dotnet run

Note

Om du kör den här koden initieras processen för att skapa instansen, vilket kan ta några minuter att slutföra.

Granska distribuerade resurser

Du kan granska den distribuerade flexibla serverinstansen via Azure Portal, Azure CLI, Azure PowerShell och olika andra verktyg för att verifiera distributionen och granska de distribuerade resurserna.

Uppdatera serverdata

Skapa en UpdateServerData.cs-fil.

Du kan också uppdatera serverdata med hjälp av Azure PostgreSQL .NET SDK.

Du kan till exempel uppdatera versionen, administratörens användarnamn, lösenord osv. med hjälp av CreateOrUpdateAsync metoden .

Metoden CreateOrUpdateAsync skapar antingen en ny instans om det inte finns någon instans med samma namn eller uppdaterar den befintliga instansen med nya serverdata om den finns.

using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql.FlexibleServers;
using Azure.ResourceManager.PostgreSql.FlexibleServers.Models;

namespace UpdateServerData
{
    class Program
 {
        static async Task Main(string[] args)
   {

            TokenCredential credential = new DefaultAzureCredential();
            ArmClient armClient = new ArmClient(credential);
            // Replace with your subscription ID
            string subscriptionId = "subscription-id";
            // Replace with your resource group name
            string resourceGroupName = "resource-group-name";
            // Replace with a unique server name
            string serverName = "server-name";
            // Replace with your desired region
            string location = "region-name";
            ResourceIdentifier resourceGroupId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
            ResourceGroupResource resourceGroup = await armClient.GetResourceGroupResource(resourceGroupId).GetAsync();
            // Prepare server data
            var serverData = new PostgreSqlFlexibleServerData(location)
           {
              // Updating version from a lower version to a higher version
              Version = "16",
           };
            try
             {
               ArmOperation<PostgreSqlFlexibleServerResource> operation = await resourceGroup.GetPostgreSqlFlexibleServers().CreateOrUpdateAsync(Azure.WaitUntil.Completed, serverName, serverData);
               PostgreSqlFlexibleServerResource serverResource = operation.Value;
               Console.WriteLine($"PostgreSQL flexible server '{serverResource.Data.Name}' updated successfully.");
            }
            catch (Exception ex)
            {
              Console.WriteLine($"An error occurred: {ex.Message}");
            }
   }
  }
}

Kör filen och granska de ändringar som gjorts i resursen med filen "UpdateServerData.cs".

Rensa resurser

Du kan rensa de skapade flexibla serverinstanserna genom att ta bort den flexibla serverinstansen med Azure SDKs för .NET.

Skapa en DeleteServer.cs fil och lägg till följande kod.

using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql.FlexibleServers;
using Azure.ResourceManager.PostgreSql.FlexibleServers.Models;

namespace DeleteServer
{
    class Program
  {
        static async Task Main(string[] args)
   {

            // Replace with your subscription ID
            string subscriptionId = "subscription-id";
            // Replace with your resource group name
            string resourceGroupName = "resource-group-name";
            // Replace with a unique server name
            string serverName = "server-name";
            var credential = new DefaultAzureCredential();
            var armClient = new ArmClient(credential);
            try
            {
                // Get the PostgreSQL flexible server resource
                var postgresServerResourceId = PostgreSqlFlexibleServerResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, serverName);
                var postgresServer = armClient.GetPostgreSqlFlexibleServerResource(postgresServerResourceId);
                // Delete the server
                await postgresServer.DeleteAsync(Azure.WaitUntil.Completed);
                Console.WriteLine($"PostgreSQL flexible server '{serverName}' deleted successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
   }
  }
}

Ersätt följande parametrar med dina data:

subscription-id: Ditt eget prenumerations-ID.
resource-group-name: Namnet på den resursgrupp som du vill använda. Skriptet skapar en ny resursgrupp om den inte finns.
server-name: Namnet på azure-databasens flexibla serverinstans som du skapade.

Du kan också ta bort resursgruppen som skapats via portalen, CLI eller PowerShell. Följ stegen som nämns i AVSNITTET CLI och PowerShell om du vill ta bort det med hjälp av CLI eller PowerShell.

Ersätt platshållarna med din information och kör filen.

Du kan också ta bort resursgruppen med hjälp av:

Azure CLI:az group delete --name <resource_group>
PowerShell:Remove-AzResourceGroup -Name <resource_group>
Azure Portal: Navigera till resursgruppen och ta bort den.

Snabbstart: Skapa en flexibel Azure Database for PostgreSQL-server

Feedback

Var den här sidan till hjälp?

Last updated on 2026-06-12