Entwickeln von Azure Functions mithilfe von Visual Studio

In Visual Studio können Sie C#-Klassenbibliotheksfunktionen entwickeln, testen und in Azure bereitstellen. Wenn diese Erfahrung Ihr erstes mit Azure Functions ist, lesen Sie die Übersicht über Azure Functions.

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.

Wichtig

Die Unterstützung für das In-Process-Modell endet am 10. November 2026. Es wird empfohlen, Ihre Apps zum isolierten Workermodell zu migrieren.

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.

• Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

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 8 (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.

   

   Einstellung	Wert	Beschreibung
   .NET-Version	.NET 8	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.

   

   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 local.settings.json Datei geheime Schlüssel enthalten kann, müssen Sie sie aus der Quellcodeverwaltung des 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. Während der lokalen Entwicklung werden diese Einstellungen stattdessen der Sammlung in der Valueslocal.settings.json Datei hinzugefügt. Die Datei „local.settings.json“ speichert auch Einstellungen, die von lokalen Entwicklungstools verwendet werden.

Elemente in der Sammlung in der Valueslocal.settings.json-Datei Ihres Projekts sollen Elemente in den Anwendungseinstellungen Ihrer Funktions-App in Azure spiegeln.

Visual Studio lädt die Einstellungen nicht automatisch in local.settings.json 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 local.settings.json Datei, und legen Sie den Wert des AzureWebJobsStorage Schlüssels 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.

   

   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: {messageText}", 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 vorherige 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. Ein vollständiges Beispiel für dieses Szenario finden Sie unter Verbinden von Funktionen mit Azure Storage mit Visual Studio.

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 Funktionsprojekt zu debuggen, beginnt der lokale Funktionenhost (func.exe) mit dem Überwachen eines lokalen Ports (normalerweise 7071). Alle aufrufbaren Funktionsendpunkte werden in die Ausgabe geschrieben, und Sie können diese Endpunkte zum Testen Ihrer Funktionen verwenden. Weitere Informationen finden Sie unter "Entwickeln von Azure Functions lokal mithilfe von 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.

2. Wählen Sie auf "Spezifisches Ziel" die Option Azure Function App (Linux) und dann "Weiter" aus.

   Der Flex-Verbrauchsplan erfordert Linux.

3. Wählen Sie in der Funktioneninstanz " Neu erstellen" aus.

   

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 -.
   Abonnementname	Name Ihres Abonnements	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	Flex-Verbrauch	Wenn Sie Ihr Projekt in einer Funktions-App veröffentlichen, die in einem Flex-Verbrauchsplan ausgeführt wird, bezahlen Sie möglicherweise nur für Ausführungen Ihrer Funktionen-App. Andere Hostingpläne können höhere Kosten verursachen.
   Ort	Standort des App-Diensts	Wählen Sie einen Standort in einer Azure-Region aus, die vom Flex-Verbrauchsplan unterstützt wird.
   Größe des Instanzarbeitsspeichers	2048	Die Speichergröße der Instanzen des virtuellen Computers , in denen die App ausgeführt wird, die für den Flex-Verbrauchsplan eindeutig ist.
   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.

   

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. Wählen Sie "Fertig stellen" und dann auf der Registerkarte " Veröffentlichen " die Option "Veröffentlichen " aus, um das Paket bereitzustellen, das Ihre Projektdateien enthält, in Ihrer neuen Funktions-App in Azure.

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

7. 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.

   

Einstellungen für Funktions-Apps

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

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.

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.

Lokal zeigt einen Einstellungswert in der dateilocal.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. Wenn Sie ein lokales Functions-Projekt aus der Quellcodeverwaltung klonen, verfügt das Projekt nicht über eine local.settings.json Datei. In diesem Fall müssen Sie die local.settings.json Datei im Projektstamm manuell erstellen, damit das Dialogfeld "Anwendungseinstellungen " wie erwartet funktioniert.

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

• Verwenden des Azure-Portals
• Verwenden der --publish-local-settings Veröffentlichungsoption in den Azure Functions Core Tools
• Verwenden der Azure-CLI

Remotedebuggen

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.
• Während Sie debuggen, sendet der Server Daten an Visual Studio, was sich auf Bandbreitengebühren auswirken kann. Informationen zu Bandbreitenraten finden Sie unter Preisrechner.
• 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 Publishsettings-Datei enthält Ihre Anmeldeinformationen (nicht codiert), die zum Verwalten Ihrer Funktions-App 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. Ein böswilliger Benutzer, der Zugriff auf die Publishsettings-Datei erhält, kann Ihre Funktions-App 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.

   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 bricht das Standarddebugging nicht in Ihren Code auf.

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.

   

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.

   

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.

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 C#-In-Process-Modellprojekt erstellen, das Sie mit xUnit testen können, bei dem es sich um ein Open-Source-Komponententesttool für .NET handelt.

Schritt 1: Einrichtung

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.

Schritt 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: Geltungsbereiche 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: Es wird ein Standardwert false angegeben.

   • Log: Diese Methode verwendet die bereitgestellte formatter Funktion zum Formatieren der Nachricht und fügt dann den resultierenden Text zur 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-Wert-Paar als Argumente und gibt eine neue Dictionary zurück, die verwendet wird, um QueryCollection zur Darstellung von Abfragezeichenfolgenwerten zu erstellen.

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

   • CreateLogger: Basierend auf dem Loggertyp gibt diese Methode eine Loggerklasse zurück, die für Tests 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 name=Bill einer 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 Beispieldaten für die HTTP-Funktion bereitzustellen.

   • Timer_should_log_message: Dieser Test erstellt eine Instanz von ListLogger und übergibt sie an eine Zeitgeberfunktion. 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 -Instanz mit simulierten Umgebungsvariablenwerten in Ihre Funktion IConfiguration.

Schritt 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.

Schritt 4: Debugtests

Um die Tests zu debuggen, legen Sie einen Haltepunkt für einen Test fest, navigieren Sie dann zum Test-Explorer , und wählen Sie "Letzte Ausführung ausführen" > aus.

Verwandte Inhalte

• Lokales Entwickeln von Azure-Funktionen mithilfe von Core Tools

• Leitfaden zum In-Process-Modell in C#

• Leitfaden zum isolierten Workermodell in C#