Schritt-für-Schritt-Anleitung: So können Sie eine functionapp slot identity zu einer postgresql database hinzufügen

In der heutigen Cloud-Ära ist die Sicherheit und Effizienz des Datenbankzugriffs von entscheidender Bedeutung. Entwickler stehen oft vor der Herausforderung, sensible Anmeldeinformationen wie Benutzernamen und Passwörter für Datenbankverbindungen sicher zu verwalten, zu rotieren und zu schützen. Hier kommen Verwaltete Identitäten (Managed Identities) ins Spiel, eine leistungsstarke Funktion von Azure, die passwortlose Verbindungen zwischen Azure-Diensten ermöglicht. Dieser Artikel führt Sie detailliert durch den Prozess, wie Sie eine Function App Slot Identity nutzen können, um sich sicher und ohne manuelle Anmeldeinformationen mit einer Azure Database for PostgreSQL zu verbinden.

Stellen Sie sich vor, Sie haben eine Azure Function App mit verschiedenen Bereitstellungsslots (Deployment Slots) für Entwicklung, Staging und Produktion. Jeder Slot kann eine eigene Identität besitzen, was eine granulare Zugriffssteuerung ermöglicht. Wir zeigen Ihnen, wie Sie diese Identität nutzen, um einen sicheren und kennwortlosen Zugang zu Ihrer PostgreSQL-Datenbank zu gewährleisten.

Warum Managed Identities für Function App Slots und PostgreSQL?

Die Verwendung von Managed Identities bietet eine Vielzahl von Vorteilen, insbesondere in komplexen Cloud-Umgebungen:

• Erhöhte Sicherheit: Keine Anmeldeinformationen im Code, in Konfigurationsdateien oder in Umgebungsvariablen. Dies eliminiert das Risiko von Credential Leaks und vereinfacht die Einhaltung von Sicherheitsstandards.
• Vereinfachte Credential-Verwaltung: Azure übernimmt die Verwaltung und Rotation der Anmeldeinformationen für Sie. Kein manuelles Rotieren von Passwörtern mehr.
• Granulare Zugriffskontrolle: Mit einer dedizierten Identität für jeden Function App Slot können Sie präzise festlegen, welche Berechtigungen der Staging-Slot im Vergleich zum Produktions-Slot in der Datenbank hat.
• Auditierbarkeit: Alle Zugriffe über Managed Identities werden in Azure AD protokolliert, was die Nachvollziehbarkeit und Compliance verbessert.
• Konformität: Erleichtert die Einhaltung von Industriestandards und Compliance-Vorschriften, die eine sichere Geheimnisverwaltung erfordern.

Die Kombination einer Function App Slot Identity mit einer PostgreSQL-Datenbank, die Azure Active Directory (Azure AD)-Authentifizierung unterstützt, ist eine Best Practice für moderne Cloud-Anwendungen.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Ressourcen und Tools zur Hand haben:

• Ein Azure-Konto mit einem aktiven Abonnement.
• Eine bestehende Azure Function App mit mindestens einem konfigurierten Bereitstellungsslot (z.B. „staging”).
• Eine Azure Database for PostgreSQL Instanz (Flexible Server wird empfohlen, da sie erweiterte Azure AD-Funktionen bietet, aber Single Server funktioniert ebenfalls mit leicht angepassten Schritten).
• Den Azure CLI oder Azure PowerShell, installiert auf Ihrem lokalen Rechner oder über Azure Cloud Shell.
• Ein PostgreSQL-Client wie `psql` oder ein GUI-Tool wie DBeaver/Azure Data Studio, das die Verbindung zu PostgreSQL über Azure AD-Authentifizierung ermöglicht.
• Die erforderlichen Berechtigungen in Ihrem Azure-Abonnement, um Dienste zu erstellen, zu konfigurieren und Azure AD-Rollen zu verwalten.

Schritt-für-Schritt-Anleitung

Schritt 1: Aktivieren der Managed Identity für den Function App Slot

Der erste Schritt besteht darin, eine System-zugewiesene Managed Identity für Ihren spezifischen Function App Slot zu aktivieren. Diese Identität wird automatisch von Azure erstellt und in Azure Active Directory registriert.

1. Navigieren Sie im Azure-Portal zu Ihrer Function App.
2. Klicken Sie im linken Menü unter „Bereitstellung” auf „Bereitstellungsslots”.
3. Wählen Sie den gewünschten Slot aus (z.B. „staging”).
4. Im Menü des ausgewählten Slots klicken Sie unter „Einstellungen” auf „Identität”.
5. Wählen Sie den Reiter „System zugewiesen” aus und schalten Sie den Status auf „Ein”. Klicken Sie dann auf „Speichern”.
6. Nach dem Speichern wird eine Objekt-ID (Principal ID) für die Managed Identity angezeigt. Notieren Sie sich diese ID, da wir sie später benötigen, um Berechtigungen in PostgreSQL zuzuweisen. Diese Objekt-ID ist die eindeutige Kennung Ihrer Slot-Identität in Azure AD.

Alternativ können Sie dies auch über die Azure CLI tun:

az functionapp identity assign 
  --resource-group <IhrRessourcengruppenname> 
  --name <IhrFunctionAppName> 
  --slot <IhrSlotName> 
  --output json

Der Befehl gibt die Details der Managed Identity zurück, einschließlich der principalId, die Sie sich notieren müssen.

Schritt 2: Konfigurieren des Azure AD Admin für PostgreSQL

Damit Ihre PostgreSQL-Datenbank Azure AD-Identitäten authentifizieren kann, muss ein Azure AD-Administrator für den PostgreSQL-Server festgelegt werden. Dieser Administrator ist der initiale Benutzer, der andere Azure AD-Benutzer und -Gruppen in der Datenbank verwalten kann.

1. Navigieren Sie im Azure-Portal zu Ihrer Azure Database for PostgreSQL-Serverinstanz (Flexible oder Single Server).
2. Klicken Sie im linken Menü unter „Einstellungen” auf „Azure Active Directory”.
3. Klicken Sie auf „Administrator festlegen” (oder „AAD-Administrator festlegen”).
4. Suchen Sie im sich öffnenden Fenster nach einem Azure AD-Benutzer oder einer Gruppe in Ihrem Abonnement, die als Administrator fungieren soll. Dies ist oft ein Benutzerkonto, das Sie selbst verwenden, oder eine dedizierte Administratorgruppe.
5. Wählen Sie den Benutzer/die Gruppe aus und klicken Sie auf „Auswählen” und dann auf „Speichern”.

Dieser Schritt ist entscheidend, da ohne einen Azure AD-Administrator keine Azure AD-Authentifizierung für die PostgreSQL-Datenbank konfiguriert werden kann. Es kann einige Minuten dauern, bis die Änderung wirksam wird.

Schritt 3: Sammeln der notwendigen Informationen

Bevor wir uns mit der Datenbank verbinden, stellen Sie sicher, dass Sie alle benötigten Informationen gesammelt haben:

• Die Objekt-ID (Principal ID) der Managed Identity Ihres Function App Slots (aus Schritt 1).
• Den vollständigen Servernamen Ihrer Azure Database for PostgreSQL-Instanz (z.B. `your-pg-server.postgres.database.azure.com`).
• Den Namen Ihrer Datenbank, auf die der Slot zugreifen soll (z.B. `mydatabase`).
• Die Anmeldeinformationen (Benutzername und Passwort oder ein Azure AD-Token) des Azure AD-Administrators, den Sie in Schritt 2 festgelegt haben.

Schritt 4: Verbinden mit PostgreSQL als Azure AD Admin

Um die Managed Identity in PostgreSQL zu registrieren und ihr Berechtigungen zuzuweisen, müssen Sie sich als der in Schritt 2 festgelegte Azure AD-Administrator mit der Datenbank verbinden. Für `psql` benötigen Sie ein Azure AD-Zugriffstoken.

1. Token abrufen: Melden Sie sich mit dem Azure CLI als Ihr Azure AD-Administrator an und fordern Sie ein Zugriffstoken an:

   az account get-access-token --resource-type https://ossrdbms-aad.database.windows.net --query "accessToken" --output tsv

   Kopieren Sie das zurückgegebene Zugriffstoken. Dieses Token dient als Ihr Passwort für die Verbindung.

2. Verbinden mit `psql`: Verwenden Sie den `psql`-Client, um sich mit Ihrer PostgreSQL-Datenbank zu verbinden. Verwenden Sie dabei den Benutzernamen des Azure AD-Administrators und das erhaltene Token als Passwort.

   psql "host=<IhrPostgreSQLServerName> user=<IhrAADAdminBenutzername>@<IhrPostgreSQLServerName> dbname=<IhrDatenbankname> password=<DasZugriffstoken> sslmode=require"

   Stellen Sie sicher, dass Sie die Platzhalter ``, `` und `` durch Ihre tatsächlichen Werte ersetzen. Der Benutzername muss oft das Format `benutzer@server` haben.

Schritt 5: Erstellen einer Rolle für die Managed Identity in PostgreSQL

Innerhalb Ihrer PostgreSQL-Datenbank müssen Sie eine neue Rolle (User) erstellen, die der Objekt-ID Ihrer Function App Slot Managed Identity entspricht. PostgreSQL erkennt diese speziellen IDs als Azure AD-Benutzer.

Führen Sie im `psql`-Client (nach erfolgreicher Verbindung) den folgenden SQL-Befehl aus:

CREATE ROLE "<Objekt-ID-der-Managed-Identity>" WITH LOGIN;

Ersetzen Sie `` durch die Principal ID, die Sie in Schritt 1 notiert haben. Die Anführungszeichen sind wichtig, da Objekt-IDs Bindestriche enthalten können.

Dieser Befehl erstellt eine neue Datenbankrolle, die die Managed Identity repräsentiert. PostgreSQL wird die Authentifizierung über Azure AD prüfen und dieser Rolle erlauben, sich zu verbinden.

Schritt 6: Zuweisen von Berechtigungen in PostgreSQL

Nachdem die Rolle erstellt wurde, müssen Sie ihr die notwendigen Berechtigungen in Ihrer Datenbank zuweisen. Das Prinzip der geringsten Rechte (Principle of Least Privilege) sollte hier stets angewendet werden – gewähren Sie nur die Berechtigungen, die der Slot tatsächlich benötigt.

Hier sind einige gängige Berechtigungen, die Sie möglicherweise gewähren müssen:

1. Verbinden mit der Datenbank:

   GRANT CONNECT ON DATABASE <IhrDatenbankname> TO "<Objekt-ID-der-Managed-Identity>";

2. Nutzungsrechte für Schemas (z.B. `public`):

   GRANT USAGE ON SCHEMA public TO "<Objekt-ID-der-Managed-Identity>";

3. Zugriff auf bestimmte Tabellen (Beispiel: Lese- und Schreibzugriff auf `MeineTabelle`):

   GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE <MeineTabelle> TO "<Objekt-ID-der-Managed-Identity>";

4. Zugriff auf alle Tabellen in einem Schema (für zukünftige Tabellen):

   ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "<Objekt-ID-der-Managed-Identity>";

Passen Sie diese Befehle an Ihre spezifischen Anforderungen an. Denken Sie daran, dass `public` oft das Standardschema ist, aber Sie könnten auch eigene Schemas verwenden.

Schritt 7: Konfigurieren der Verbindungszeichenfolge in der Function App

Der letzte Schritt auf der Azure-Seite ist die Konfiguration Ihrer Function App Slot-Einstellungen, damit Ihre Anwendung die Managed Identity für die Datenbankverbindung nutzen kann. Die Verbindungszeichenfolge wird nun kein Passwort mehr enthalten.

1. Navigieren Sie im Azure-Portal wieder zu Ihrem Function App Slot.
2. Klicken Sie im linken Menü unter „Einstellungen” auf „Konfiguration”.
3. Fügen Sie eine neue Anwendungseinstellung hinzu (oder aktualisieren Sie eine bestehende).
4. Geben Sie für „Name” einen aussagekräftigen Namen ein (z.B. `PostgreSQLConnection`).
5. Für „Wert” verwenden Sie eine Verbindungszeichenfolge, die die Managed Identity-Authentifizierung aktiviert:

   Host=<IhrPostgreSQLServerName>;Port=5432;Database=<IhrDatenbankname>;Authentication=ActiveDirectoryManagedIdentity;

   Ersetzen Sie `` und `` durch Ihre tatsächlichen Werte.

   Der Schlüssel hier ist Authentication=ActiveDirectoryManagedIdentity;, der `Npgsql` (der .NET PostgreSQL-Treiber) anweist, ein Zugriffstoken von der Azure AD-Identität des Dienstes anzufordern, auf dem die Anwendung läuft.

6. Klicken Sie auf „OK” und dann auf „Speichern” oben im Konfigurationsbereich.

Schritt 8: Implementierung im Code der Function App

In Ihrer Function App müssen Sie nun Ihren Code anpassen, um die neue Verbindungszeichenfolge zu verwenden. Für .NET-Anwendungen, die `Npgsql` (den PostgreSQL-Treiber für .NET) verwenden, ist dies unkompliziert.

Stellen Sie sicher, dass Sie die folgenden NuGet-Pakete in Ihrem Projekt installiert haben:

• `Npgsql`
• `Azure.Identity` (oft implizit durch `Npgsql` bei Managed Identity-Authentifizierung gehandhabt, aber explizite Referenz kann helfen).

Ein Beispiel in C# könnte so aussehen:

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Npgsql;
using Microsoft.Extensions.Logging;

public static class MyFunction
{
    [FunctionName("GetPostgreData")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req,
        ILogger log, ExecutionContext context)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        // Konfiguration laden (z.B. aus appsettings.json oder Umgebungsvariablen)
        var config = new ConfigurationBuilder()
            .SetBasePath(context.FunctionAppDirectory)
            .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
            .AddEnvironmentVariables()
            .Build();

        string connectionString = config.GetValue<string>("PostgreSQLConnection"); // Der Name aus Schritt 7

        if (string.IsNullOrEmpty(connectionString))
        {
            return new BadRequestObjectResult("PostgreSQLConnection string is not configured.");
        }

        try
        {
            using (var conn = new NpgsqlConnection(connectionString))
            {
                await conn.OpenAsync();
                log.LogInformation("Successfully connected to PostgreSQL database using Managed Identity.");

                using (var cmd = new NpgsqlCommand("SELECT version();", conn))
                {
                    var result = await cmd.ExecuteScalarAsync();
                    log.LogInformation($"PostgreSQL Version: {result}");
                    return new OkObjectResult($"Connected to PostgreSQL. Version: {result}");
                }
            }
        }
        catch (Exception ex)
        {
            log.LogError($"Error connecting to PostgreSQL: {ex.Message}");
            return new StatusCodeResult(StatusCodes.Status500InternalServerError);
        }
    }
}

Dieser Code liest die Verbindungszeichenfolge aus den Anwendungseinstellungen und versucht, eine Verbindung zur PostgreSQL-Datenbank herzustellen. Da die Verbindungszeichenfolge `Authentication=ActiveDirectoryManagedIdentity` enthält, wird der `Npgsql`-Treiber automatisch die Managed Identity des Function App Slots nutzen, um ein Zugriffstoken von Azure AD zu erhalten und sich damit zu authentifizieren.

Testen der Verbindung

Nachdem Sie die Änderungen im Code vorgenommen und Ihren Function App Slot aktualisiert haben, können Sie die Verbindung testen:

1. Stellen Sie sicher, dass Ihr Function App Slot bereitgestellt ist.
2. Triggeren Sie Ihre Funktion (z.B. über die HTTP-URL, wenn es sich um eine HTTP-Trigger-Funktion handelt).
3. Überprüfen Sie die Anwendungsprotokolle im Azure-Portal (unter „Log Stream” oder „Monitor” -> „Protokolle”) auf Erfolgs- oder Fehlermeldungen bezüglich der Datenbankverbindung.

Wenn alles korrekt konfiguriert ist, sollten Sie eine erfolgreiche Verbindung zur Datenbank sehen, ohne dass Anmeldeinformationen im Code oder in den Einstellungen sichtbar sind.

Best Practices und Überlegungen

• Principle of Least Privilege: Gewähren Sie der Managed Identity immer nur die minimal erforderlichen Berechtigungen in der Datenbank.
• Umwelt-Spezifische Identitäten: Durch die Verwendung von Slot-spezifischen Managed Identities können Sie unterschiedliche Berechtigungssätze für Staging- und Produktionsumgebungen definieren, was die Sicherheit weiter erhöht.
• Überwachung: Überwachen Sie den Datenbankzugriff und die Azure AD-Anmeldeereignisse, um ungewöhnliche Aktivitäten zu erkennen.
• User-assigned Managed Identities: Für Szenarien, in denen mehrere Ressourcen die gleiche Identität nutzen sollen, können Sie Benutzer-zugewiesene Managed Identities in Betracht ziehen. Für einen einzelnen Slot ist die System-zugewiesene Identität jedoch meist die einfachere Wahl.
• Fehlerbehebung: Wenn Probleme auftreten, überprüfen Sie die Azure AD-Admin-Konfiguration auf dem PostgreSQL-Server, die Objekt-ID der Managed Identity, die PostgreSQL-Rolle und deren Berechtigungen sowie die Verbindungszeichenfolge in der Function App.

Fazit

Die Integration einer Function App Slot Identity mit einer Azure Database for PostgreSQL über Managed Identities ist ein Paradebeispiel für moderne, sichere und wartungsarme Cloud-Architekturen. Sie eliminiert die Notwendigkeit, sensible Anmeldeinformationen zu verwalten, verbessert die Sicherheit, vereinfacht die Compliance und bietet eine robuste Lösung für den Datenbankzugriff in Ihren Serverless-Anwendungen. Durch die Befolgung dieser Schritt-für-Schritt-Anleitung können Sie Ihre Anwendung sicher konfigurieren und von den Vorteilen der passwortlosen Authentifizierung profitieren.

Nehmen Sie sich die Zeit, diese Best Practice in Ihren Projekten zu implementieren, und erleben Sie die Vorteile einer sichereren und effizienteren Cloud-Entwicklung!