Freigeben über

Entwickeln von Azure Functions mithilfe von Visual Studio

  • Artikel

In Visual Studio können Sie C#-Klassenbibliotheksfunktionen entwickeln, testen und in Azure bereitstellen. Wenn Sie zum ersten Mal mit Azure Functions arbeiten, finden Sie unter Einführung in Azure Functions weitere Informationen.

Um sofort loszulegen, sollten Sie den Functions-Schnellstart für Visual Studio abschließen.

Dieser Artikel erläutert detailliert, wie Sie Visual Studio verwenden, um C#-Klassenbibliotheksfunktionen zu entwickeln und in Azure zu veröffentlichen. Es gibt zwei Modelle für die Entwicklung von C#-Klassenbibliotheksfunktionen: das isolierte Workermodell und das In-Process-Modell.

Sie lesen gerade die Version zum isolierten Workermodell dieses Artikels. Sie können Ihr bevorzugtes Modell oben im Artikel auswählen.

Sie lesen gerade die Version zum In-Process-Modell dieses Artikels. Sie können Ihr bevorzugtes Modell oben im Artikel auswählen.

Sofern nicht anders angegeben, gelten die gezeigten Prozeduren und Beispiele für Visual Studio 2022. Weitere Informationen zu Visual Studio 2022-Versionen finden Sie in den Versionshinweisen oder den Vorschau-Versionshinweisen.

Voraussetzungen

  • Visual Studio 2022 einschließlich der Workload Azure-Entwicklung.

  • Andere Ressourcen, die Sie benötigen, z. B. ein Azure Storage-Konto, werden während des Veröffentlichungsprozesses in Ihrem Abonnement erstellt.

  • Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.

Erstellen eines Azure Functions-Projekts

Mit der Azure Functions-Projektvorlage in Visual Studio wird ein Bibliotheksprojekt der Klasse C# erstellt, das Sie in einer Funktions-App in Azure veröffentlichen können. Sie können mit einer Funktions-App Funktionen zu logischen Einheiten gruppieren. Dies erleichtert die Verwaltung, Bereitstellung, Skalierung und Freigabe von Ressourcen.

  1. Wählen Sie im Visual Studio-Menü Datei>Neu>Projekt aus.

  2. Geben Sie unter Neues Projekt erstellen den Suchbegriff functions in das Suchfeld ein, und wählen Sie die Vorlage Azure Functions und anschließend Weiter aus.

  3. Geben Sie unter Neues Projekt konfigurieren im Feld Projektname einen Namen für Ihr Projekt ein, und wählen Sie anschließend Erstellen aus. Der Name der Funktions-App muss als C#-Namespace gültig sein, verwenden Sie daher keine Unterstriche, Bindestriche oder andere nicht alphanumerische Zeichen.

  4. Verwenden Sie für die Einstellungen zum Erstellen einer neuen Azure Functions-Anwendung die Werte in der folgenden Tabelle:

    Einstellung Wert Beschreibung
    .NET-Version .NET 6 (isoliert) Dieser Wert erstellt ein Funktionsprojekt, das in einem isolierten Workerprozess ausgeführt wird. Der isolierte Arbeitsprozess unterstützt andere Nicht-LTS-Versionen von .NET und .NET Framework. Weitere Informationen finden Sie unter Einstellen von Runtimeversionen von Azure Functions als Ziel.
    Funktionsvorlage HTTP-Trigger Mit diesem Wert wird eine Funktion erstellt, die durch eine HTTP-Anforderung ausgelöst wird.
    Speicherkonto (AzureWebJobsStorage) Speicheremulator Da für eine Funktions-App in Azure ein Speicherkonto erforderlich ist, wird ein Speicherkonto zugewiesen oder erstellt, wenn Sie Ihr Projekt in Azure veröffentlichen. Von HTTP-Triggern wird keine Azure Storage-Kontoverbindungszeichenfolge verwendet. Für alle anderen Triggertypen ist dagegen eine gültige Azure Storage-Kontoverbindungszeichenfolge erforderlich.
    Autorisierungsstufe Anonym Die erstellte Funktion kann von jedem Client ausgelöst werden, ohne dass ein Schlüssel angegeben werden muss. Diese Autorisierungseinstellung erleichtert Ihnen das Testen Ihrer neuen Funktion. Weitere Informationen finden Sie unter Autorisierungsebene.

    Screenshot der Azure Functions-Projekteinstellungen

    Einstellung Wert Beschreibung
    .NET-Version .NET 6 Dieser Wert erstellt ein Funktionsprojekt, das prozessintern mit Version 4.x der Azure Functions-Runtime ausgeführt wird. Weitere Informationen finden Sie unter Einstellen von Runtimeversionen von Azure Functions als Ziel.
    Funktionsvorlage HTTP-Trigger Mit diesem Wert wird eine Funktion erstellt, die durch eine HTTP-Anforderung ausgelöst wird.
    Speicherkonto (AzureWebJobsStorage) Speicheremulator Da für eine Funktions-App in Azure ein Speicherkonto erforderlich ist, wird ein Speicherkonto zugewiesen oder erstellt, wenn Sie Ihr Projekt in Azure veröffentlichen. Von HTTP-Triggern wird keine Azure Storage-Kontoverbindungszeichenfolge verwendet. Für alle anderen Triggertypen ist dagegen eine gültige Azure Storage-Kontoverbindungszeichenfolge erforderlich.
    Autorisierungsstufe Anonym Die erstellte Funktion kann von jedem Client ausgelöst werden, ohne dass ein Schlüssel angegeben werden muss. Diese Autorisierungseinstellung erleichtert Ihnen das Testen Ihrer neuen Funktion. Weitere Informationen finden Sie unter Autorisierungsebene.

    Screenshot der Azure Functions-Projekteinstellungen

    Stellen Sie sicher, dass Autorisierungsstufe auf Anonym festgelegt ist. Bei Verwendung der Standardebene Funktion muss in Anforderungen für den Zugriff auf den Funktionsendpunkt der Funktionsschlüssel angegeben werden.

  5. Wählen Sie Erstellen aus, um das Funktionsprojekt und die HTTP-Triggerfunktion zu erstellen.

Nach dem Erstellen eines Azure Functions-Projekts erstellt die Projektvorlage ein C#-Projekt, installiert die NuGet-Pakete Microsoft.Azure.Functions.Worker und Microsoft.Azure.Functions.Worker.Sdk und legt das Zielframework fest.

Nach dem Erstellen eines Azure Functions-Projekts erstellt die Projektvorlage ein C#-Projekt, installiert das NuGet-Paket Microsoft.NET.Sdk.Functions und legt das Zielframework fest.

Das neue Projekt enthält die folgenden Dateien:

  • host.json: Ermöglicht das Konfigurieren des Functions-Hosts. Diese Einstellungen gelten für die lokale Ausführung und die Ausführung in Azure. Weitere Informationen finden Sie in der host.json-Referenz.

  • local.settings.json: Behält Einstellungen beim lokalen Ausführen von Funktionen bei. Diese Einstellungen werden bei der Ausführung in Azure nicht verwendet. Weitere Informationen finden Sie unter Datei für lokale Einstellungen.

    Wichtig

    Da die Datei „local.settings.json“ Geheimnisse enthalten kann, müssen Sie sie aus der Quellcodeverwaltung Ihres Projekts ausschließen. Stellen Sie sicher, dass die Einstellung In Ausgabeverzeichnis kopieren für diese Datei auf Kopieren, falls aktueller festgelegt ist.

Weitere Informationen finden Sie unter Projektstruktur im Leitfaden zu isolierten Workern.

Weitere Informationen finden Sie unter Funktionsklassenbibliotheks-Projekt.

Lokales Arbeiten mit App-Einstellungen

Bei der Ausführung in einer Funktions-App in Azure werden die von Ihren Funktionen benötigten Einstellungen sicher in den App-Einstellungen gespeichert. Bei der lokalen Entwicklung werden diese Einstellungen stattdessen zur Values-Sammlung in der Datei local.settings.json hinzugefügt. Die Datei „local.settings.json“ speichert auch Einstellungen, die von lokalen Entwicklungstools verwendet werden.

Elemente in der Values-Sammlung in der Datei local.settings.json Ihres Projekts sollen Elemente in den Anwendungseinstellungen Ihrer Funktions-App in Azure widerspiegeln.

Visual Studio lädt die Einstellungen in „local.settings.json“ nicht automatisch hoch, wenn Sie das Projekt veröffentlichen. Um sicherzustellen, dass diese Einstellungen auch in Ihrer Funktions-App in Azure vorhanden sind, laden Sie sie nach dem Veröffentlichen Ihres Projekts hoch. Weitere Informationen finden Sie unter Einstellungen für Funktions-Apps. Die Werte in einer ConnectionStrings-Sammlung werden nie veröffentlicht.

Ihr Code kann die Werte für Funktions-App-Einstellungen auch als Umgebungsvariablen lesen. Weitere Informationen finden Sie unter Umgebungsvariablen.

Konfigurieren des Projekts für die lokale Entwicklung

Die Functions-Laufzeit verwendet intern ein Azure-Speicherkonto. Legen Sie für alle Triggertypen außer HTTP und Webhooks den Schlüssel Values.AzureWebJobsStorage auf eine gültige Verbindungszeichenfolge für ein Azure Storage-Konto fest. Ihre Funktions-App kann auch den Azurite-Emulator für die Verbindungseinstellung AzureWebJobsStorage verwenden, die für das Projekt erforderlich ist. Um den Emulator zu verwenden, legen Sie den Wert für AzureWebJobsStorage auf UseDevelopmentStorage=true fest. Ändern Sie diese Einstellung vor der Bereitstellung in eine tatsächliche Verbindungszeichenfolge für ein Speicherkonto. Weitere Informationen finden Sie unter Emulator für lokalen Speicher.

So legen Sie die Speicherkonto-Verbindungszeichenfolge fest:

  1. Navigieren Sie im Azure-Portal zu Ihrem Speicherkonto.

  2. Kopieren Sie auf der Registerkarte Zugriffsschlüssel unter Sicherheit und Netzwerk die Verbindungszeichenfolgekey1.

  3. Öffnen Sie in Ihrem Projekt die Datei „local.settings.json“, und legen Sie den Wert des Schlüssels AzureWebJobsStorage auf die kopierte Verbindungszeichenfolge fest.

  4. Wiederholen Sie den vorherigen Schritt zum Hinzufügen von eindeutigen Schlüsseln zum Array Values für alle anderen Verbindungen, die für Ihre Funktionen erforderlich sind.

Hinzufügen einer Funktion zu Ihrem Projekt

In C#-Klassenbibliotheksfunktionen werden die von der Funktion verwendeten Bindungen durch Anwendung von Attributen im Code definiert. Wenn Sie Funktionstrigger aus den bereitgestellten Vorlagen erstellen, werden die Triggerattribute für Sie angewendet.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten, und wählen Sie Hinzufügen>Neue Azure-Funktion aus.

  2. Geben Sie einen Namen für die Klasse ein, und klicken Sie dann auf Hinzufügen.

  3. Wählen Sie den Auslöser aus, legen Sie die erforderlichen Bindungseigenschaften fest, und wählen Sie dann Hinzufügen aus. Im folgenden Beispiel werden die Einstellungen zum Erstellen einer Queue Storage-Triggerfunktion gezeigt.

    Erstellen einer Queue Storage-Triggerfunktion

    Für einen Azure Storage-Dienstauslöser aktivieren Sie das Kästchen Verbindung konfigurieren, und Sie werden aufgefordert, zwischen der Verwendung eines Azurite-Speicheremulators oder dem Verweis auf ein bereitgestelltes Azure-Speicherkonto zu wählen. Wählen Sie Weiter aus, und wenn Sie ein Speicherkonto auswählen, versucht Visual Studio, eine Verbindung mit Ihrem Azure-Konto herzustellen und die Verbindungszeichenfolge abzurufen. Wählen Sie Wert der Verbindungszeichenfolge in Geheimnisdatei des lokalen Benutzers speichern und dann Fertig stellen aus, um die Auslöserklasse zu erstellen.

    In diesem Auslöserbbeispiel wird eine Anwendungseinstellung für die Speicherverbindung mit einem Schlüssel namens QueueStorage verwendet. Dieser Schlüssel, der in der Datei „local.settings.json“ gespeichert ist, verweist entweder auf den Azurite-Emulator oder auf ein Azure-Speicherkonto.

  4. Untersuchen Sie die neu hinzugefügte Klasse. Die folgende C#-Klasse stellt beispielsweise eine einfache Queue Storage-Triggerfunktion dar:

    Es wird eine statische Run()-Methode mit dem Attribut Function angezeigt. Dieses Attribut gibt an, dass die Methode den Einstiegspunkt für die Funktion darstellt.

    using System;
using Azure.Storage.Queues.Models;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        private readonly ILogger<QueueTriggerCSharp> _logger;

        public QueueTriggerCSharp(ILogger<QueueTriggerCSharp> logger)
        {
            _logger = logger;
        }

        [Function(nameof(QueueTriggerCSharp))]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")] QueueMessage message)
        {
            _logger.LogInformation($"C# Queue trigger function processed: {message.MessageText}");
        }
    }
}

    Es wird eine statische Run()-Methode mit dem Attribut FunctionName angezeigt. Dieses Attribut gibt an, dass die Methode den Einstiegspunkt für die Funktion darstellt.

    using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        [FunctionName("QueueTriggerCSharp")]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")]string myQueueItem, ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        }
    }
}

Ein bindungsspezifisches Attribut wird auf jeden Bindungsparameter angewendet, der der Einstiegspunktmethode bereitgestellt wird. Das Attribut verwendet die Bindungsinformationen als Parameter. Im vorherigen Beispiel wurde auf den ersten Parameter ein QueueTrigger-Attribut angewandt, das auf eine Queue Storage-Triggerfunktion hinweist. Die Namen der Warteschlange und der Einstellung für die Verbindungszeichenfolge werden als Parameter an das QueueTrigger-Attribut übergeben. Weitere Informationen finden Sie unter Azure Queue Storage-Bindungen für Azure Functions.

Verwenden Sie das oben angegebene Verfahren, um Ihrem Funktions-App-Projekt weitere Funktionen hinzuzufügen. Jede Funktion im Projekt kann über einen anderen Trigger verfügen, aber einer Funktion muss genau ein Trigger zugeordnet sein. Weitere Informationen finden Sie unter Konzepte für Azure Functions-Trigger und -Bindungen.

Hinzufügen von Bindungen

Wie bei Triggern auch, werden Eingabe- und Ausgabebindungen Ihrer Funktion als Bindungsattribute hinzugefügt. Fügen Sie Bindungen einer Funktion wie folgt hinzu:

  1. Achten Sie darauf, das Projekt für lokale Entwicklung zu konfigurieren.

  2. Fügen Sie das entsprechende NuGet-Erweiterungspaket für die spezifische Bindung hinzu, indem Sie die bindungsspezifischen NuGet-Paketanforderungen im Referenzartikel für die Bindung finden. Paketanforderungen für den Event Hubs-Trigger finden Sie im Referenzartikel zu Event Hubs-Bindungen.

  3. Verwenden Sie den folgenden Befehl in der Paket-Manager-Konsole, um ein bestimmtes Paket zu installieren:

    Install-Package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    Ersetzen Sie in diesem Beispiel <BINDING_TYPE> den Namen, der für die Bindungserweiterung spezifisch ist, und <TARGET_VERSION> durch eine bestimmte Version des Pakets, z. B. 4.0.0. Gültige Versionen sind auf den Seiten der einzelnen Pakete auf NuGet.org aufgeführt.

  4. Falls für die Bindung bestimmte App-Einstellungen erforderlich sind, können Sie diese der Sammlung Values in der Datei mit lokalen Einstellungen hinzufügen.

    Die-Funktion verwendet diese Werte, wenn sie lokal ausgeführt wird. Wenn die Funktion in der Funktions-App in Azure ausgeführt wird, werden die Einstellungen für Funktions-Apps verwendet. Visual Studio erleichtert das Veröffentlichen lokaler Einstellungen in Azure.

  5. Fügen Sie der Methodensignatur das entsprechende Bindungsattribut hinzu. Im folgenden Beispiel löst eine Warteschlangennachricht die Funktion aus, und die Ausgabebindung erstellt eine neue Warteschlangennachricht mit demselben Text in einer anderen Warteschlange.

     public class QueueTrigger
{
    private readonly ILogger _logger;

    public QueueTrigger(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<QueueTrigger>();
    }

    [Function("CopyQueueMessage")]
    [QueueOutput("myqueue-items-destination", Connection = "QueueStorage")]
    public string Run([QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem)
    {
        _logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        return myQueueItem;
    }
}

    Das Attribut QueueOutput definiert die Bindung für die Methode. Für mehrere Ausgabebindungen würden Sie dieses Attribut stattdessen auf eine Zeichenfolgeneigenschaft des zurückgegebenen Objekts festlegen. Weitere Informationen finden Sie unter Mehrere Ausgabebindungen.

    public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem, 
        [Queue("myqueue-items-destination", Connection = "QueueStorage")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

    Das Attribut Queue für den Parameter out definiert die Ausgabebindung.

    Die Verbindung mit dem Warteschlangenspeicher stammt aus der Einstellung QueueStorage. Weitere Informationen finden Sie im Referenzartikel für die spezifische Bindung.

Eine vollständige Liste der von Functions unterstützten Bindungen finden Sie unter Unterstützte Bindungen.

Lokales Ausführen von Funktionen

Mit Azure Functions Core-Tools können Sie ein Azure Functions-Projekt auf dem lokalen Entwicklungscomputer ausführen. Wenn Sie F5 drücken, um ein Functions-Projekt zu debuggen, beginnt der lokale Functions-Host („func.exe“), an einem lokalen Port (normalerweise Port 7071) zu lauschen. Alle aufrufbaren Funktionsendpunkte werden in die Ausgabe geschrieben, und Sie können diese Endpunkte zum Testen Ihrer Funktionen verwenden. Weitere Informationen finden Sie unter Arbeiten mit Azure Functions Core Tools. Sie werden beim ersten Starten einer Funktion in Visual Studio zum Installieren dieser Tools aufgefordert.

Wichtig

Ab der Version 4.0.6517 von Core Tools müssen In-Process-Modellprojekte mindestens auf die Version 4.5.0 von Microsoft.NET.Sdk.Functions verweisen. Bei Verwendung einer älteren Version tritt bei dem Befehl func start ein Fehler auf.

So starten Sie Ihre Funktion im Debugmodus in Visual Studio:

  1. Drücken Sie F5. Akzeptieren Sie die entsprechende Aufforderung von Visual Studio zum Herunterladen und Installieren der Azure Functions Core (CLI)-Tools. Sie müssen möglicherweise auch eine Firewallausnahme aktivieren, damit die Tools HTTP-Anforderungen verarbeiten können.

  2. Wenn das Projekt ausgeführt wird, testen Sie Ihren Code wie eine bereitgestellte Funktion.

    Wenn Sie Visual Studio im Debuggingmodus ausführen, werden wie erwartet Breakpoints erreicht.

Ein ausführlicheres Testszenario mit Visual Studio finden Sie unter Testen von Funktionen.

Veröffentlichen in Azure

Wenn Sie Ihr Funktionsprojekt in Azure veröffentlichen, verwendet Visual Studio die ZIP-Bereitstellung, um die Projektdateien bereitzustellen. Wenn möglich, sollten Sie auch die Ausführung über ein Paket auswählen, damit das Projekt im Bereitstellungspaket (.zip) ausgeführt wird. Weitere Informationen finden Sie unter Ausführen Ihrer Funktionen aus einer Paketdatei in Azure.

Verwenden Sie nicht Web Deploy (msdeploy) für Bereitstellungen in Azure Functions.

Verwenden Sie die folgenden Schritte, um Ihr Projekt in einer Funktions-App in Azure zu veröffentlichen.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Veröffentlichen aus. Wählen Sie unter Ziel die Option Azure und dann Weiter aus.

    Screenshot: Bereich „Veröffentlichen“.

  2. Wählen Sie unter Spezifisches Ziel die Option Azure-Funktions-App (Windows) aus. Es wird eine Funktions-App erstellt, die unter Windows ausgeführt wird. Wählen Sie Weiter aus.

    Screenshot: Bereich „Veröffentlichen“ mit einem bestimmten Ziel.

  3. Wählen Sie unter Functions-Instanz die Option Neue Azure-Funktion erstellen aus.

    Screenshot: Erstellen einer neuen Funktions-App-Instanz.

  4. Erstellen Sie eine neue Instanz mit den Werten aus der folgenden Tabelle:

    Einstellung Wert Beschreibung
    Name Global eindeutiger Name Name, der Ihre neue Funktions-App eindeutig identifiziert. Übernehmen Sie diesen Namen, oder geben Sie einen neuen Namen ein. Gültige Zeichen: a-z, 0-9 und -.
    Abonnement Ihr Abonnement Das zu verwendende Azure-Abonnement. Übernehmen Sie dieses Abonnement, oder wählen Sie in der Dropdownliste ein neues Abonnement aus.
    Ressourcengruppe Name Ihrer Ressourcengruppe Die Ressourcengruppe, in der Sie Ihre Funktions-App erstellen möchten. Wählen Sie Neu aus, um eine neue Ressourcengruppe zu erstellen. Sie können auch eine vorhandene Ressourcengruppe in der Dropdownliste auswählen.
    Plantyp Nutzung Wenn Sie Ihr Projekt in einer Funktions-App veröffentlichen, die in einem Verbrauchsplan ausgeführt wird, bezahlen Sie nur für die Ausführungen Ihrer Funktions-App. Für andere Hostingpläne fallen höhere Kosten an.
    Location Standort des App-Diensts Wählen Sie einen Standort in einer Azure-Region in Ihrer Nähe oder in der Nähe anderer Dienste aus, auf die Ihre Funktionen zugreifen.
    Azure Storage (in englischer Sprache) Universelles Speicherkonto Für die Functions-Laufzeit ist ein Azure-Speicherkonto erforderlich. Wählen Sie Neu aus, um ein universelles Speicherkonto zu konfigurieren. Sie können auch ein vorhandenes Konto auswählen, das die Anforderungen an das Speicherkonto erfüllt.
    Application Insights Application Insights-Instanz Sie sollten die Azure Application Insights-Integration für Ihre Funktions-App aktivieren. Wählen Sie Neu aus, um eine neue Instanz in einem neuen oder einem vorhandenen Log Analytics-Arbeitsbereich zu erstellen. Sie können auch eine vorhandene Instanz auswählen.

    Screenshot: Dialogfeld „App Service erstellen“.

  5. Wählen Sie Erstellen aus, um eine Funktions-App und die zugehörigen Ressourcen in Azure zu erstellen. Der Status der Ressourcenerstellung wird in der linken unteren Ecke im Fenster angezeigt.

  6. Stellen Sie unter Functions-Instanz sicher, dass das Kontrollkästchen Aus Paketdatei ausführen aktiviert ist. Ihre Funktions-App wird unter Verwendung der ZIP-Bereitstellung mit aktiviertem Modus Run-From-Package bereitgestellt. Zip Deploy ist die empfohlene Bereitstellungsmethode für Ihr Funktionsprojekt, da damit eine bessere Leistung erzielt wird.

    Screenshot: Bereich „Profilerstellung fertig stellen“.

  7. Wählen Sie Fertig stellen und dann im Bereich Veröffentlichen die Option Veröffentlichen aus, um das Paket mit Ihren Projektdateien in der neuen Funktions-App in Azure bereitzustellen.

    Nach Abschluss der Bereitstellung wird die Stamm-URL der Funktions-App in Azure auf der Registerkarte Veröffentlichen angezeigt.

  8. Wählen Sie auf der Registerkarte Veröffentlichen im Abschnitt Hosting die Option Im Azure-Portal öffnen aus. Die Azure-Ressource für die neue Funktions-App wird im Azure-Portal geöffnet.

    Screenshot: Meldung zum erfolgreichen Veröffentlichen.

Einstellungen für Funktions-Apps

Visual Studio lädt diese Einstellungen nicht automatisch hoch, wenn Sie das Projekt veröffentlichen. Alle Einstellungen, die Sie in „local.settings.json“ hinzufügen, müssen auch der Funktions-App in Azure hinzugefügt werden.

Die einfachste Möglichkeit zum Hochladen der erforderlichen Einstellungen in Ihre Funktions-App in Azure ist das Erweitern der drei Punkte neben dem Abschnitt Hosting und das Auswählen des Links Azure App Service-Einstellungen bearbeiten, der nach dem erfolgreichen Veröffentlichen des Projekts angezeigt wird.

Einstellungen im Fenster „Veröffentlichen“

Durch Auswählen dieses Links wird das Dialogfeld Anwendungseinstellungen für die Funktions-App angezeigt, in dem Sie neue Anwendungseinstellungen hinzufügen oder vorhandene ändern können.

Anwendungseinstellungen

Lokal zeigt einen Einstellungswert in der Datei „local.settings.json“ an, und Remote zeigt einen aktuellen Einstellungswert in der Funktions-App in Azure an. Wählen Sie Einstellung hinzufügen, um eine neue App-Einstellung zu erstellen. Verwenden Sie den Link Wert aus lokaler Quelle einfügen, um einen Einstellungswert in das Feld Remote zu kopieren. Ausstehende Änderungen werden in die Datei für lokale Einstellungen und die Funktions-App geschrieben, wenn Sie OK auswählen.

Hinweis

Standardmäßig wird die Datei „local.settings.json“ nicht in die Quellcodeverwaltung eingecheckt. Dies bedeutet, dass das Projekt beim Klonen eines lokalen Functions-Projekts aus der Quellcodeverwaltung keine Datei „local.settings.json“ enthält. In diesem Fall müssen Sie die Datei „local.settings.json“ manuell im Projektstamm erstellen, damit das Dialogfeld Anwendungseinstellungen erwartungsgemäß funktioniert.

Sie können die Anwendungseinstellungen auch folgendermaßen verwalten:

Remote Debugging

Um Ihre Funktions-App remote zu debuggen, müssen Sie eine Debugkonfiguration Ihres Projekts veröffentlichen. Sie müssen auch das Remotedebuggen in Ihrer Funktions-App in Azure aktivieren.

In diesem Abschnitt wird davon ausgegangen, dass Sie bereits in Ihrer Funktions-App mit einer Versionskonfiguration veröffentlicht haben.

Überlegungen zum Remotedebuggen

  • Remotedebuggen wird für einen Produktionsdienst nicht empfohlen.
  • Wenn die Option Nur eigenen Code debuggen aktiviert ist, deaktivieren Sie sie.
  • Vermeiden Sie es beim Remotedebuggen, lange an Breakpoints anzuhalten. Azure behandelt Prozesse, die länger als einige Minuten angehalten sind, als nicht reagierend und beendet diese.
  • Beim Debuggen schickt der Server Daten an Visual Studio und verursacht möglicherweise zusätzliche Kosten für Bandbreite. Weitere Informationen zu Bandbreitentarifen finden Sie unter Azure Pricing(Azure-Preisübersicht, in englischer Sprache).
  • Das Remotedebuggen wird in Ihrer Funktions-App nach 48 Stunden automatisch deaktiviert. Nach 48 Stunden müssen Sie das Remotedebuggen erneut ausführen.

Fügen Sie den Debugger an.

Die Art und Weise, wie Sie den Debugger anfügen, hängt vom Ausführungsmodus ab. Beim Debuggen einer isolierten Workerprozess-App müssen Sie derzeit den Remotedebugger an einen separaten .NET-Prozess anfügen, und mehrere weitere Konfigurationsschritte sind erforderlich.

Wenn Sie fertig sind, sollten Sie das Remotedebuggen deaktivieren.

So fügen Sie einen Remotedebugger an eine Funktions-App an, die in einem Prozess getrennt vom Functions-Host ausgeführt wird:

  1. Wählen Sie auf der Registerkarte Veröffentlichen die Auslassungspunkte (...) im Abschnitt Hosting aus, und wählen Sie dann Debugger anfügen aus. Diese Aktion lädt eine Kopie des Veröffentlichungsprofils herunter und öffnet den Downloadspeicherort. Sie benötigen diese Datei, die die Anmeldeinformationen enthält, die zum Anfügen an Ihren isolierten Workerprozess verwendet werden, der in Azure ausgeführt wird.

    Achtung

    Die Datei „publishsettings“ enthält die (nicht codierten) Anmeldeinformationen, die zur Verwaltung der -Abonnements und -Dienste verwendet werden. Die bewährte Sicherheitsmethode für diese Datei besteht im vorübergehenden Speichern außerhalb Ihrer Quellverzeichnisse (beispielsweise im Ordner „Libraries\Documents“). Löschen Sie sie, wenn sie nicht mehr benötigt wird. Böswillige Benutzer, die Zugriff auf die Datei „.publishsettings“ erlangen, können Ihre Azure-Dienste bearbeiten, erstellen und löschen.

  2. Wählen Sie auf der Registerkarte Veröffentlichen erneut die Auslassungspunkte (...) im Abschnitt Hosting aus, und wählen Sie dann Debugger anfügen aus.

    Screenshot des Anfügens des Debuggers aus Visual Studio.

    Visual Studio verbindet sich mit Ihrer Funktions-App und aktiviert das Remotedebuggen, wenn es noch nicht aktiviert ist.

    Hinweis

    Da der Remotedebugger keine Verbindung mit dem Hostprozess herstellen kann, könnte ein Fehler angezeigt werden. In jedem Fall wird das Standarddebuggen Ihren Code nicht unterbrechen.

  3. Kopieren Sie in Visual Studio die URL für die Site unter Hosting auf der Seite Veröffentlichen.

  4. Wählen Sie im Menü Debuggen die Option An Prozess anfügen aus, und fügen Sie im Fenster An Prozess anfügen die URL im Verbindungsziel ein, entfernen Sie https:// und fügen Sie den Port :4024 an.

    Stellen Sie sicher, dass Ihr Ziel wie <FUNCTION_APP>.azurewebsites.net:4024 aussieht, und drücken Sie die Eingabetaste.

    Visual Studio-Dialogfeld „An Prozess anfügen“

  5. Wenn Sie aufgefordert werden, können Sie den Zugriff von Visual Studio über ihre lokale Firewall zulassen.

  6. Wenn Sie zu Anmeldeinformationen aufgefordert werden, wählen Sie anstelle von lokalen Benutzeranmeldeinformationen ein anderes Konto (Weitere Optionen unter Windows) aus. Geben Sie die Werte von UserName und UserPWD aus dem veröffentlichten Profil für E-Mail-Adresse und Kennwort im Authentifizierungsdialogfeld unter Windows an. Nachdem eine sichere Verbindung mit dem Bereitstellungsserver eingerichtet wurde, werden die verfügbaren Prozesse angezeigt.

    Visual Studio-Anmeldeinformationen eingeben

  7. Aktivieren Sie Prozesse aller Benutzer anzeigen, wählen Sie dann dotnet.exe aus, und wählen Sie Anfügen aus. Wenn der Vorgang abgeschlossen ist, sind Sie mit dem Code Ihrer C#-Klassenbibliothek verbunden, der in einem isolierten Workerprozess ausgeführt wird. An diesem Punkt können Sie Ihre Funktions-App wie normal debuggen.

So fügen Sie einen Remotedebugger an eine Funktions-App an, die mit dem Funktionshost ausgeführt wird:

  • Wählen Sie auf der Registerkarte Veröffentlichen die Auslassungspunkte (...) im Abschnitt Hosting aus, und wählen Sie dann Debugger anfügen aus.

    Screenshot des Anfügens des Debuggers aus Visual Studio.

Visual Studio verbindet sich mit Ihrer Funktions-App und aktiviert das Remotedebuggen, wenn es noch nicht aktiviert ist. Außerdem wird der Debugger an den Hostprozess für die App lokalisiert und angefügt. An diesem Punkt können Sie Ihre Funktions-App wie normal debuggen.

Deaktivieren des Remotedebuggen

Nachdem Sie das Remotedebuggen abgeschlossen haben, sollten Sie das Remotedebuggen im Azure-Portal deaktivieren. Das Remotedebuggen wird automatisch nach 48 Stunden deaktiviert, falls Sie vergessen.

  1. Wählen Sie auf der Registerkarte Veröffentlichen in Ihrem Projekt die Auslassungspunkte (...) im Abschnitt Hosting aus, und wählen Sie In Azure-Portal öffnen aus. Diese Aktion öffnet die Funktions-App in der Azure-Portal, für die Ihr Projekt bereitgestellt wird.

  2. Wählen Sie in der Funktions-App unter Einstellungen die Option Konfiguration aus, wählen Sie Allgemeine Einstellungen aus, legen Sie Remotedebuggen auf Aus fest, und wählen Sie Speichern und dann Weiter aus.

Nachdem die Funktions-App neu gestartet wurde, können Sie keine Remoteverbindung mehr mit Ihren Remoteprozessen herstellen. Sie können diese Registerkarte im Azure-Portal verwenden, um das Remotedebuggen außerhalb von Visual Studio zu aktivieren.

Überwachen von Funktionen

Die empfohlene Methode zum Überwachen der Ausführung Ihrer Funktionen ist die Integration Ihrer Funktions-App in Azure Application Insights. Sie sollten diese Integration aktivieren, wenn Sie Ihre Funktions-App während der Veröffentlichung in Visual Studio erstellen.

Wenn die Integration aus irgendeinem Grund nicht während der Veröffentlichung erfolgt ist, sollten Sie dennoch die Application Insights-Integration für Ihre Funktions-App in Azure aktivieren.

Weitere Informationen zum Überwachen mithilfe von Application Insights finden Sie unter Überwachen von Azure Functions.

Testen von Funktionen

In diesem Abschnitt wird beschrieben, wie Sie ein In-Process-Modellprojekt in C# erstellen, das Sie mit xUnit testen können.

Testen von Azure Functions mit C# in Visual Studio

1. Einrichten

Führen Sie die folgenden Schritte aus, um die Umgebung zu konfigurieren, einschließlich des App-Projekts und der Funktionen, die erforderlich sind, um Ihre Tests zu unterstützen:

  1. Erstellen Sie eine neue Functions-App, und nennen Sie sie Functions
  2. Erstellen Sie eine HTTP-Funktion aus der Vorlage, und nennen Sie sie MyHttpTrigger.
  3. Erstellen Sie eine Zeitgeberfunktion aus der Vorlage, und nennen Sie sie MyTimerTrigger.
  4. Erstellen Sie eine xUnit-Test-App in der Projektmappe, und nennen Sie sie Functions.Tests. Entfernen Sie die Standardtestdateien.
  5. Fügen Sie mithilfe von NuGet einen Verweis von der Test-App auf Microsoft.AspNetCore.Mvc hinzu.
  6. Verweisen Sie aus der Functions.Tests-App auf die Functions-App.

Nachdem nun die Projekte erstellt wurden, können Sie die Klassen erstellen, die zum Ausführen der automatisierten Tests verwendet werden.

2. Erstellen von Testklassen

Jede Funktion verwendet eine Instanz von ILogger für die Nachrichtenprotokollierung. Einige Tests protokollieren entweder keine Nachrichten oder ignorieren, wie die Protokollierung implementiert wird. Andere Tests müssen protokollierte Nachrichten auswerten, um zu bestimmen, ob ein Test bestanden wird.

  1. Erstellen Sie eine neue Klasse mit dem Namen ListLogger, die eine interne Liste von während Tests ausgewerteten Nachrichten enthält. Zum Implementieren der erforderlichen ILogger-Schnittstelle benötigt die Klasse einen Gültigkeitsbereich. Die folgende Klasse simuliert einen Bereich für die Testfälle, die an die ListLogger-Klasse übergeben werden sollen.

  2. Erstellen Sie in Ihrem Projekt Functions.Tests eine neue Klasse mit dem Namen NullScope.cs, und fügen Sie diesen Code hinzu:

    using System;

namespace Functions.Tests
{
    public class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new NullScope();

        private NullScope() { }

        public void Dispose() { }
    }
}

  3. Erstellen Sie in Ihrem Projekt Functions.Tests eine Klasse mit dem Namen ListLogger.cs, und fügen Sie diesen Code hinzu:

    using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;

namespace Functions.Tests
{
    public class ListLogger : ILogger
    {
        public IList<string> Logs;

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => false;

        public ListLogger()
        {
            this.Logs = new List<string>();
        }

        public void Log<TState>(LogLevel logLevel,
                                EventId eventId,
                                TState state,
                                Exception exception,
                                Func<TState, Exception, string> formatter)
        {
            string message = formatter(state, exception);
            this.Logs.Add(message);
        }
    }
}

    Die ListLogger-Klasse implementiert die folgenden Elemente, wie durch die ILogger-Schnittstelle vereinbart:

    • BeginScope: Bereiche fügen Ihrer Protokollierung Kontext hinzu. In diesem Fall verweist der Test einfach auf die statische Instanz in der NullScope-Klasse, damit der Test funktionieren kann.

    • IsEnabled: Ein Standardwert von false wird bereitgestellt.

    • Log: Diese Methode verwendet die angegebene formatter-Funktion, um die Nachricht zu formatieren, und fügt dann den resultierenden Text der Logs-Auflistung hinzu.

    Die Logs-Auflistung ist eine Instanz von List<string> und wird im Konstruktor initialisiert.

  4. Erstellen Sie im Projekt Functions.Tests eine Codedatei mit dem Namen LoggerTypes.cs, und fügen Sie diesen Code hinzu:

    namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}

    Diese Enumeration gibt den Typ der Protokollierung an, die von den Tests verwendet wird.

  5. Erstellen Sie im Projekt Functions.Tests eine Klasse mit dem Namen TestFactory.cs, und fügen Sie diesen Code hinzu:

    using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Primitives;
using System.Collections.Generic;

namespace Functions.Tests
{
    public class TestFactory
    {
        public static IEnumerable<object[]> Data()
        {
            return new List<object[]>
            {
                new object[] { "name", "Bill" },
                new object[] { "name", "Paul" },
                new object[] { "name", "Steve" }

            };
        }

        private static Dictionary<string, StringValues> CreateDictionary(string key, string value)
        {
            var qs = new Dictionary<string, StringValues>
            {
                { key, value }
            };
            return qs;
        }

        public static HttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)
        {
            var context = new DefaultHttpContext();
            var request = context.Request;
            request.Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue));
            return request;
        }

        public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
        {
            ILogger logger;

            if (type == LoggerTypes.List)
            {
                logger = new ListLogger();
            }
            else
            {
                logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
            }

            return logger;
        }
    }
}

    Die TestFactory-Klasse implementiert die folgenden Elemente:

    • Data: Diese Eigenschaft gibt eine IEnumerable-Auflistung von Beispieldaten zurück. Die Schlüssel-/Wertpaare stellen Werte dar, die in eine Abfragezeichenfolge übergeben werden.

    • CreateDictionary: Diese Methode akzeptiert ein Schlüssel-/Wertpaar als Argumente und gibt ein neues Dictionary zurück, das verwendet wird, um QueryCollection zu erstellen, um Abfragezeichenfolgenwerte darzustellen.

    • CreateHttpRequest: Diese Methode erstellt eine HTTP-Anforderung, die mit den angegebenen Abfragezeichenfolgenparametern initialisiert wird.

    • CreateLogger: Basierend auf dem Typ des Protokollierungstools gibt diese Methode eine Protokollierungsklasse zurück, die zum Testen verwendet wird. ListLogger verfolgt die protokollierten Nachrichten, die zur Evaluierung in Tests zur Verfügung stehen.

  6. Erstellen Sie im Projekt Functions.Tests eine Klasse mit dem Namen FunctionsTests.cs, und fügen Sie diesen Code hinzu:

    using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Xunit;

namespace Functions.Tests
{
    public class FunctionsTests
    {
        private readonly ILogger logger = TestFactory.CreateLogger();

        [Fact]
        public async void Http_trigger_should_return_known_string()
        {
            var request = TestFactory.CreateHttpRequest("name", "Bill");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bill. This HTTP triggered function executed successfully.", response.Value);
        }

        [Theory]
        [MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
        public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey, string queryStringValue)
        {
            var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal($"Hello, {queryStringValue}. This HTTP triggered function executed successfully.", response.Value);
        }

        [Fact]
        public void Timer_should_log_message()
        {
            var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
            new MyTimerTrigger().Run(null, logger);
            var msg = logger.Logs[0];
            Assert.Contains("C# Timer trigger function executed at", msg);
        }
    }
}

    Die in dieser Klasse implementierten Elemente sind:

    • Http_trigger_should_return_known_string: Dieser Test erstellt eine Anforderung mit den Abfragezeichenfolgenwerten von name=Bill an eine HTTP-Funktion und überprüft, ob die erwartete Antwort zurückgegeben wird.

    • Http_trigger_should_return_string_from_member_data: Dieser Test verwendet xUnit-Attribute, um der HTTP-Funktion Beispieldaten bereitzustellen.

    • Timer_should_log_message: Dieser Test erstellt eine Instanz von ListLogger und übergibt sie an eine Timerfunktion. Sobald die Funktion ausgeführt wird, wird das Protokoll überprüft, um sicherzustellen, dass die erwartete Nachricht vorhanden ist.

  7. Für den Zugriff auf Anwendungseinstellungen in Ihren Tests können Sie eine IConfiguration-Instanz mit simulierten Umgebungsvariablenwerten in Ihre Funktion einschleusen.

3. Ausführen von Tests

Navigieren Sie zum Ausführen der Tests zum Test-Explorer, und wählen Sie Alle Tests in der Ansicht ausführen aus.

Testen von Azure Functions mit C# in Visual Studio

4. Debuggen von Tests

Um die Tests zu debuggen, legen Sie bei einem Test einen Breakpoint fest, navigieren Sie zum Test-Explorer, und wählen Sie Ausführen > Letzte Ausführung debuggen aus.

Nächste Schritte

Weitere Informationen zu Azure Functions Core Tools finden Sie unter Arbeiten mit Azure Functions Core Tools.

Leitfaden zum In-Process-Modell in C#

Leitfaden zum isolierten Workermodell in C#