Entwickeln von Azure Functions mithilfe von Visual Studio

Visual Studio bietet eine Möglichkeit zum Entwickeln, Testen und Bereitstellen von C#-Klassenbibliotheksfunktionen in Azure. 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 enthält ausführliche Informationen zur Verwendung von Visual Studio zum Entwickeln von C#-Klassenbibliotheksfunktionen und deren Veröffentlichung in Azure. Es gibt zwei Modelle für die Entwicklung von C#-Klassenbibliotheksfunktionen: das isolierte Workermodell und das In-Process-Modell.

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

Sie lesen die In-Process-Modellversion 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 in den Vorschauversionshinweisen.

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.

Wählen Sie im Visual Studio-Menü Datei>Neu>Projekt aus.
Geben Sie im Dialogfeld " Neues Projekt erstellen " Funktionen in das Suchfeld ein, wählen Sie die Vorlage "Azure-Funktionen" und dann "Weiter" aus.
Geben Sie im Dialogfeld " Neues Projekt konfigurieren" für "Projektname" einen Namen für Ihr Projekt ein, und wählen Sie dann "Weiter" aus. Der Name der Funktions-App muss als C#-Namespace gültig sein, verwenden Sie daher keine Unterstriche, Bindestriche oder andere nicht alphanumerische Zeichen.

Führen Sie im Dialogfeld "Zusätzliche Informationen " die in der folgenden Tabelle aufgeführten Aktionen aus:

Einstellung	Maßnahme	BESCHREIBUNG
Functions-Worker	Wählen Sie .NET 8.0 Isoliert (langfristiger Support) aus.	Visual Studio erstellt ein Funktionsprojekt, das in einem isolierten Arbeitsprozess ausgeführt wird. Der isolierte Arbeitsprozess unterstützt auch andere Versionen von .NET und .NET Framework, die keinen langfristigen Support (LTS) bieten. Weitere Informationen finden Sie unter Einstellen von Runtimeversionen von Azure Functions als Ziel.
Function	Wählen Sie "HTTP-Trigger" aus.	Visual Studio erstellt eine Funktion, die von einer HTTP-Anforderung ausgelöst wird.
Verwenden von Azurite für das Laufzeitspeicherkonto (AzureWebJobsStorage)	Aktivieren Sie dieses Kontrollkästchen.	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. Ein HTTP-Trigger verwendet keine Speicherkontoverbindungszeichenfolge. Für alle anderen Triggertypen ist eine gültige Speicherkontoverbindungszeichenfolge erforderlich.
Autorisierungsstufe	Wählen Sie "Anonym" aus.	Wenn Sie diese Autorisierungseinstellung verwenden, kann jeder Client die erstellte Funktion auslösen, ohne einen Schlüssel bereitzustellen. Diese Konfiguration erleichtert das Testen ihrer neuen Funktion. Weitere Informationen finden Sie unter Autorisierungsebene.

Einstellung	Maßnahme	BESCHREIBUNG
Functions-Worker	Wählen Sie .NET 8.0 In-Process (Long Term Support) aus.	Visual Studio erstellt ein Funktionsprojekt, das mit Version 4.x der Funktionslaufzeit ausgeführt wird. Weitere Informationen finden Sie unter Einstellen von Runtimeversionen von Azure Functions als Ziel.
Function	Wählen Sie "HTTP-Trigger" aus.	Visual Studio erstellt eine Funktion, die von einer HTTP-Anforderung ausgelöst wird.
Verwenden von Azurite für das Laufzeitspeicherkonto (AzureWebJobsStorage)	Aktivieren Sie dieses Kontrollkästchen.	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. Ein HTTP-Trigger verwendet keine Speicherkontoverbindungszeichenfolge. Für alle anderen Triggertypen ist eine gültige Speicherkontoverbindungszeichenfolge erforderlich.
Autorisierungsstufe	Anonym auswählen	Wenn Sie diese Autorisierungseinstellung verwenden, kann jeder Client die erstellte Funktion auslösen, ohne einen Schlüssel bereitzustellen. Diese Konfiguration erleichtert das Testen ihrer neuen Funktion. Weitere Informationen finden Sie unter Autorisierungsebene.

Stellen Sie sicher, dass Autorisierungsstufe auf Anonym festgelegt ist. Wenn Sie die Standardebene der Funktion auswählen, müssen Sie den Funktionsschlüssel in Anforderungen für den Zugriff auf Ihren Funktionsendpunkt präsentieren.

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

Nachdem Sie ein Funktionsprojekt erstellt haben, erstellt die Projektvorlage ein C#-Projekt, installiert die Microsoft.Azure.Functions.Worker Pakete und Microsoft.Azure.Functions.Worker.Sdk NuGet-Pakete und legt das Zielframework fest.

Nachdem Sie ein Funktionsprojekt erstellt haben, erstellt die Projektvorlage ein C#-Projekt, installiert das Microsoft.NET.Sdk.Functions NuGet-Paket und legt das Zielframework fest.

Das neue Projekt enthält die folgenden Dateien:

host.json: Diese Datei bietet eine Möglichkeit zum Konfigurieren des Funktionenhosts. 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: Diese Datei verwaltet Einstellungen, die Sie beim lokalen Ausführen von Funktionen verwenden. Diese Einstellungen werden nicht verwendet, wenn Ihre App in Azure ausgeführt wird. Weitere Informationen finden Sie unter "Lokales Arbeiten mit App-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 im Dialogfeld "Eigenschaften" für diese Datei sicher, dass die Einstellung "In Ausgabeordner kopieren" auf "Kopieren, wenn neuer" festgelegt ist.

Weitere Informationen finden Sie in der Projektstruktur im isolierten Arbeiter-Leitfaden.

Weitere Informationen finden Sie unter Funktionsklassenbibliotheks-Projekt.

Lokales Arbeiten mit App-Einstellungen

Wenn Ihre Funktions-App in Azure ausgeführt wird, werden die von Ihren Funktionen erforderlichen Einstellungen in den App-Einstellungen verschlüsselt gespeichert. Während der lokalen Entwicklung werden diese Einstellungen stattdessen der Sammlung in der Valueslocal.settings.json Datei hinzugefügt. Die dateilocal.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 Auflistung werden nicht 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

Das Laufzeitsystem von Functions verwendet intern ein Speicherkonto. Während der Entwicklung können Sie ein gültiges Speicherkonto für dieses interne Konto verwenden oder den Azurite-Emulator verwenden.

Für alle Triggertypen außer HTTP und Webhooks müssen Sie den Wert des Values.AzureWebJobsStorage Schlüssels in der dateilocal.settings.json festlegen:

Legen Sie für ein Speicherkonto den Wert auf die Verbindungszeichenfolge Ihres Speicherkontos fest.
Legen Sie für den Emulator den Wert auf UseDevelopmentStorage=true.

Wenn Sie den Emulator verwenden, ändern Sie diese Einstellung vor der Bereitstellung in eine tatsächliche Verbindungszeichenfolge für Speicherkonten. Weitere Informationen finden Sie unter Emulator für lokalen Speicher.

Führen Sie die folgenden Schritte aus, um die Verbindungszeichenfolge für das Speicherkonto festzulegen:

Melden Sie sich beim Azure-Portal an, und wechseln Sie dann zu Ihrem Speicherkonto.
Wählen Sie "Sicherheit+>" aus. Kopieren Sie unter Schlüssel1 den Wert der Verbindungszeichenfolge .
Öffnen Sie in Ihrem Visual Studio-Projekt die local.settings.json Datei. Legen Sie den Wert des AzureWebJobsStorage Schlüssels auf die verbindungszeichenfolge fest, die Sie kopiert haben.
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 Bindungen, die von den verwendeten Funktionen verwendet werden, durch Anwenden von Attributen im Code definiert. Wenn Sie Funktionstrigger aus den bereitgestellten Vorlagen erstellen, werden die Triggerattribute für Sie angewendet.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten, und wählen Sie Hinzufügen>Neue Azure-Funktion aus.
Wählen Sie im Dialogfeld " Neues Element hinzufügen " Die Azure-Funktion und dann "Hinzufügen" aus.
Wählen Sie einen Trigger aus, und legen Sie dann die erforderlichen Bindungseigenschaften fest. Wenn Sie einen Speicherdiensttrigger auswählen und die Verbindung konfigurieren möchten, aktivieren Sie das Kontrollkästchen zum Konfigurieren der Triggerverbindung. Im folgenden Beispiel werden die Einstellungen zum Erstellen einer Queue Storage-Triggerfunktion gezeigt.
Wählen Sie Hinzufügen aus. Wenn Sie das Kontrollkästchen zum Konfigurieren einer Speicherverbindung im vorherigen Schritt aktivieren, wird die Seite Mit Abhängigkeit verbinden angezeigt. Wählen Sie einen Azurite-Speicheremulator oder Azure Storage und dann Weiter aus.
- Wenn Sie einen Azurite-Speicher-Emulator auswählen, wird die Emulatorseite "Mit Storage Azurite verbinden " angezeigt. Führen Sie die folgenden Schritte aus:
  1. Wählen Sie Weiteraus.
  2. Wählen Sie auf der Seite "Zusammenfassung der Änderungen" die Option "Fertig stellen" aus. Visual Studio konfiguriert die Abhängigkeit und erstellt die Triggerklasse.
- Wenn Sie Azure Storage auswählen, wird die Seite "Mit Azure Storage verbinden " angezeigt. Führen Sie die folgenden Schritte aus:
  1. Wählen Sie ein Speicherkonto und dann "Weiter" aus. Visual Studio versucht, eine Verbindung mit Ihrem Azure-Konto herzustellen und einen Endpunkt abzurufen.
  2. Wählen Sie Weiteraus.
  3. Wählen Sie auf der Seite "Zusammenfassung der Änderungen" die Option "Fertig stellen" aus. Visual Studio konfiguriert die Abhängigkeit und erstellt die Triggerklasse.
In diesem Auslöserbbeispiel wird eine Anwendungseinstellung für die Speicherverbindung mit einem Schlüssel namens QueueStorage verwendet. Dieser Schlüssel, der in der dateilocal.settings.json gespeichert ist, verweist entweder auf den Azurite-Emulator oder auf ein Speicherkonto.

Untersuchen Sie die neu hinzugefügte Klasse. Die folgende C#-Klasse stellt z. B. eine einfache Warteschlangenspeicher-Triggerfunktion dar.

Eine Run() Methode ist mit Function attributiert. 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);
    }
}

Eine statische Run()-Methode wird mit FunctionName versehen. 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 Code hat der erste Parameter ein QueueTrigger Attribut angewendet, das eine Queue Storage-Triggerfunktion angibt. Die Namen der Warteschlange und der Einstellung für die Verbindungszeichenfolge werden als Parameter an das QueueTrigger-Attribut übergeben. In Ihrem Kurs:

Der Parameter "Warteschlangenname" sollte mit dem Namen der Warteschlange übereinstimmen, die Sie in einem früheren Schritt zum Erstellen des Triggers verwenden, z.B. myqueue-items.
Der Name der Verbindungszeichenfolgeneinstellung sollte mit dem Namen übereinstimmen, den Sie in einem früheren Schritt zum Erstellen des Triggers verwenden, z. B. QueueStorage.

Weitere Informationen finden Sie unter Azure Queue Storage Trigger für Azure Functions.

Verwenden Sie das vorstehende 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 Azure Functions-Trigger und -Bindungen.

Hinzufügen von Bindungen

Wie bei Triggern auch, werden Eingabe- und Ausgabebindungen Ihrer Funktion als Bindungsattribute hinzugefügt. Führen Sie die folgenden Schritte aus, um einer Funktion Bindungen hinzuzufügen:

Achten Sie darauf, das Projekt für lokale Entwicklung zu konfigurieren.
Fügen Sie das entsprechende NuGet-Erweiterungspaket für jede bestimmte Bindung hinzu. Die bindungsspezifischen NuGet-Paketanforderungen finden Sie im Referenzartikel für die Bindung. Informationen zu Paketanforderungen für den Azure Event Hubs-Trigger finden Sie unter Azure Event Hubs Trigger und Bindungen für Azure Functions.
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 im Code <BINDING_TYPE> durch den spezifischen Namen der Bindungserweiterung, und ersetzen Sie <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.
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.

Fügen Sie der Methodensignatur das entsprechende Bindungsattribut hinzu. Im folgenden Code löst eine Warteschlangennachricht die Run Funktion aus. Die Ausgabebindung erstellt dann 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. Bei mehreren Ausgabebindungen platzieren Sie dieses Attribut stattdessen in einer Zeichenfolgeneigenschaft des zurückgegebenen Objekts. 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 zum Warteschlangenspeicher wird aus der QueueStorage Einstellung abgerufen. 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

Sie können Azure Functions Core Tools verwenden, um Funktionen-Projekte auf Ihrem lokalen Entwicklungscomputer auszuführen. Wenn Sie F5 zum Debuggen eines Functions-Projekts auswählen, beginnt der lokale Functions-Host (func.exe) mit der Überwachung 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. Wenn Sie eine frühere Version verwenden, generiert der func start Befehl einen Fehler.

Führen Sie die folgenden Schritte aus, um Die Funktion in Visual Studio im Debugmodus zu starten:

Wählen Sie F5 aus. Wenn Sie dazu aufgefordert werden, akzeptieren Sie die Anforderung von Visual Studio, Azure Functions Core Tools herunterzuladen und zu installieren. Möglicherweise müssen Sie auch eine Firewall-Ausnahme aktivieren, damit die Tools HTTP-Anforderungen verarbeiten können.
Wenn das Projekt ausgeführt wird, testen Sie den Code auf die gleiche Weise wie eine bereitgestellte Funktion.

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

Ein detaillierteres Testszenario, das Visual Studio verwendet, finden Sie unter Testfunktionen weiter unten in diesem Artikel.

Veröffentlichen in Azure

Wenn Sie Ihr Functions-Projekt in Azure veröffentlichen, verwendet Visual Studio zip-Bereitstellung , um die Projektdateien bereitzustellen. Wenn möglich, sollten Sie auch "Aus Paketdatei ausführen" 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.

Setzen Sie keine Funktionen mithilfe von Web Deploy (msdeploy) ein.

Führen Sie die folgenden Schritte aus, um Ihr Projekt in einer Funktions-App in Azure zu veröffentlichen:

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie dann "Veröffentlichen" aus.
Treffen Sie auf der Seite "Veröffentlichen" die folgenden Auswahlen:
- Wählen Sie auf "Ziel" Azure und dann "Weiter" aus.
- Wählen Sie auf "Spezifisches Ziel" die Option "Azure Function App" und dann "Weiter" aus.
- Wählen Sie in der Funktioneninstanz " Neu erstellen" aus.

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

Einstellung	Wert	BESCHREIBUNG
Name	Global eindeutiger Name	Der Name muss Ihre neue Funktions-App eindeutig identifizieren. Akzeptieren Sie den vorgeschlagenen Namen, oder geben Sie einen neuen Namen ein. Die folgenden Zeichen sind gültig: `a-z`, , `0-9`und `-`.
Abonnementname	Der Name Ihres Abonnements	Die Funktions-App wird in einem Azure-Abonnement erstellt. Akzeptieren Sie das Standardabonnement, oder wählen Sie ein anderes Abonnement aus der Liste aus.
Ressourcengruppe	Der Name Ihrer Ressourcengruppe	Die Funktions-App wird in einer Ressourcengruppe erstellt. Wählen Sie Neu aus, um eine neue Ressourcengruppe zu erstellen. Sie können auch eine vorhandene Ressourcengruppe aus der Liste 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. WICHTIG: Beim Erstellen eines Flex-Verbrauchsplans müssen Sie zuerst den App-Serviceplan auswählen und dann "Flex-Verbrauch" erneut auswählen, um ein Problem mit dem Dialogfeld zu löschen.
Betriebssystem	Linux	Der Flex-Verbrauchsplan erfordert derzeit Linux.
Ort	Der Speicherort des App-Diensts	Wählen Sie einen Standort in einer Azure-Region aus, die vom Flex-Verbrauchsplan unterstützt wird. Wenn ein nicht unterstützter Bereich ausgewählt ist, ist die Schaltfläche " Erstellen " abgeblendet.
Größe des Instanzarbeitsspeichers	2048	Die Arbeitsspeichergröße der Instanzen des virtuellen Computers , in denen die App ausgeführt wird, ist für den Flex-Verbrauchsplan einzigartig.
Azure Storage	Ein allgemeines Speicherkonto	Für die Funktionslaufzeit ist ein Speicherkonto erforderlich. Wählen Sie Neu aus, um ein universelles Speicherkonto zu konfigurieren. Sie können auch ein vorhandenes Konto verwenden, das die Speicherkontoanforderungen erfüllt.
Application Insights	Eine Application Insights-Instanz	Sie sollten die Integration von Application Insights 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 verwenden.

Screenshot des Dialogfelds Funktions-App erstellen Felder für den Namen, das Abonnement, die Ressourcengruppe, den Plan und andere Einstellungen werden ausgefüllt.

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.
Wählen Sie "Fertig stellen" aus. Das Fenster für den Fortschritt der Profilveröffentlichung wird angezeigt. Wenn das Profil erstellt wird, wählen Sie "Schließen" aus.
Wählen Sie auf der Seite "Profil 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 Veröffentlichungsprofilseite angezeigt.
Wechseln Sie auf der Seite "Profil veröffentlichen" zum Abschnitt "Hosting" . Wählen Sie die Auslassungspunkte (...) und anschließend Öffnen im Azure-Portal 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 app-Einstellungen nicht automatisch hoch, wenn Sie Ihr Projekt veröffentlichen. Wenn Sie der local.settings.json-Datei Einstellungen hinzufügen, müssen Sie sie auch der Funktions-App in Azure hinzufügen.

Die einfachste Möglichkeit, die erforderlichen Einstellungen in Ihre Funktions-App in Azure hochzuladen, besteht darin, sie in Visual Studio zu verwalten. Wechseln Sie auf der Seite "Profil veröffentlichen" zum Abschnitt "Hosting" . Wählen Sie die Auslassungspunkte (...) aus und wählen Sie dann Azure App Service-Einstellungen verwalten.

Wenn Sie die Auswahl treffen, wird das Dialogfeld "Anwendungseinstellungen " für die Funktions-App geöffnet. Sie können dieses Dialogfeld verwenden, um Anwendungseinstellungen hinzuzufügen oder vorhandene einstellungen zu ändern.

Screenshot des Dialogfelds

Für jede Einstellung ist der lokale Wert der Wert in der local.settings.json Datei, und der Remotewert ist der Wert in der Funktions-App in Azure.

Um eine App-Einstellung zu erstellen, wählen Sie "Einstellung hinzufügen" aus.
Wenn Sie einen Einstellungswert aus dem Feld "Lokal " in das Feld "Remote " kopieren möchten, wählen Sie "Wert einfügen" aus "Lokal" aus.

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

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

Verwenden Sie das Azure-Portal.
Verwenden Sie die Veröffentlichungsoption--publish-local-settings in den Azure Functions Core Tools.
Verwenden Sie die Azure CLI.

Remotedebuggen

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

In diesem Abschnitt wird davon ausgegangen, dass eine Debugkonfiguration für Ihre Funktions-App veröffentlicht wird.

Überlegungen zum Remotedebuggen

Remotedebuggen wird für einen Produktionsdienst nicht empfohlen.
Zum Verwenden des Remotedebuggings müssen Sie Ihre Funktions-App in einem Premium- oder App Service-Plan hosten.
Remotedebugging wird derzeit nur unterstützt, wenn Ihre C#-App unter Windows ausgeführt wird.
Wenn das Feature "Nur Mein Code" in Visual Studio aktiviert ist, deaktivieren Sie es. Anweisungen finden Sie unter Aktivieren oder Deaktivieren von Just My Code.
Vermeiden Sie lange Stopps an Haltepunkten, wenn Sie Remotedebugging verwenden. Wenn ein Prozess länger als ein paar Minuten beendet wird, behandelt Azure ihn als nicht reagierenden Prozess und beendet ihn.
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 Remotedebugging wird in Ihrer Funktions-App nach 48 Stunden automatisch deaktiviert. Danach müssen Sie das Remotedebugging wieder aktivieren.

Anfügen des Debuggers

Wenn Sie eine isolierte Arbeitsprozess-App debuggen, müssen Sie den Remotedebugger derzeit an einen separaten .NET-Prozess anfügen. Es sind auch mehrere weitere Konfigurationsschritte erforderlich.

Führen Sie die folgenden Schritte aus, um einen Remotedebugger an eine Funktions-App anzufügen, die in einem vom Funktionshost getrennten Prozess ausgeführt wird:

Wechseln Sie auf der Seite "Profil veröffentlichen" zum Abschnitt "Hosting" . Wählen Sie die Ellipse (...) und dann Debugger anfügen aus.

Visual Studio stellt eine Verbindung mit Ihrer Funktions-App bereit und aktiviert das Remotedebugging, wenn es noch nicht aktiviert ist.

Hinweis

Da der Remotedebugger keine Verbindung mit dem Hostprozess herstellen kann, wird möglicherweise eine Fehlermeldung angezeigt. In jedem Fall kann der lokale Debugger nicht auf Ihre Haltepunkte zugreifen und bietet Ihnen keine Möglichkeit, Variablen zu prüfen oder Code schrittweise durchzugehen.
Wählen Sie im Menü " Debuggen " von Visual Studio die Option "An Prozess anhängen" aus.
Führen Sie im Dialogfeld "An Prozess anhängen " die folgenden Schritte aus:
1. Wählen Sie neben dem VerbindungstypMicrosoft Azure App Services aus.
2. Wählen Sie neben dem Verbindungsziel"Suchen" aus.
Suchen Sie im Dialogfeld "Azure An Prozess Anfügen" Ihre Funktions-App, wählen Sie diese aus, und klicken Sie dann auf "OK".
Wenn Sie aufgefordert werden, können Sie den Zugriff von Visual Studio über ihre lokale Firewall zulassen.
Wählen Sie im Dialogfeld "An Prozess anhängen"die Option "Prozesse für alle Benutzer anzeigen" aus. Wählen Sie dotnet.exeaus, und wählen Sie dann "Anfügen" aus.

Nach Abschluss des Vorgangs sind Sie mit Ihrem C#-Klassenbibliothekscode verbunden, der in einem isolierten Worker-Prozess ausgeführt wird. An diesem Punkt können Sie Ihre Funktions-App wie normal debuggen.

Führen Sie die folgenden Schritte aus, um einen Remotedebugger an eine Funktions-App anzufügen, die mit dem Functions-Host ausgeführt wird.

Wechseln Sie auf der Seite "Profil veröffentlichen" zum Abschnitt "Hosting" . Wählen Sie die Ellipse (...) und dann Debugger anfügen aus.

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

Wenn Sie mit dem Debuggen fertig sind, sollten Sie das Remotedebugging deaktivieren.

Deaktivieren des Remotedebuggings

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

Wechseln Sie auf der Seite "Profil veröffentlichen" zum Abschnitt "Hosting" . Wählen Sie die Auslassungspunkte (...) und anschließend Öffnen im Azure-Portal aus. Das Azure-Portal wird mit der Funktions-App geöffnet, für die Ihr Projekt bereitgestellt wird.
Wählen Sie in der Funktions-App "Einstellungskonfiguration> aus, und wechseln Sie dann zur Registerkarte "Allgemeine Einstellungen". Wählen Sie neben Remotedebuggingdie Option "Aus" aus. 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 Remotedebugging außerhalb von Visual Studio zu aktivieren.

Überwachen von Funktionen

Die empfohlene Möglichkeit, Ihre Funktionen zu überwachen, besteht darin, Ihre Funktions-App in Application Insights zu integrieren. Sie sollten diese Integration aktivieren, wenn Sie ihre Funktions-App während der Veröffentlichung von Visual Studio erstellen.

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

Weitere Informationen zur Verwendung von Application Insights für die Überwachung finden Sie unter Überwachen von Ausführungen in Azure Functions.

Testen von Funktionen

In diesem Abschnitt wird beschrieben, wie Sie ein C#-In-Process-Modellprojekt erstellen, das Sie mithilfe von xUnit, einem Open-Source-Komponententesttool für .NET, testen können.

Schritt 1: Setup

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:

Erstellen Sie in Visual Studio ein Azure Functions-Projekt mit dem Namen "Funktionen".
Erstellen Sie eine HTTP-Funktion aus der Vorlage:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt "Funktionen", und wählen Sie dann "Neue Azure-Funktion>" aus.
2. Wählen Sie im Dialogfeld " Neues Element hinzufügen " Die Azure-Funktion und dann "Hinzufügen" aus.
3. Wählen Sie "HTTP-Trigger" und dann "Hinzufügen" aus.
4. Benennen Sie die neue Klasse MyHttpTrigger um.
Erstellen Sie eine Zeitgeberfunktion aus der Vorlage:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt "Funktionen", und wählen Sie dann "Neue Azure-Funktion>" aus.
2. Wählen Sie im Dialogfeld " Neues Element hinzufügen " Die Azure-Funktion und dann "Hinzufügen" aus.
3. Wählen Sie Timertrigger und dann Hinzufügen aus.
4. Benennen Sie die neue Klasse MyTimerTrigger um.
Erstellen Sie eine xUnit Test-App in der Lösung:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, die Ihr Funktionen-Projekt enthält, und wählen Sie dann Hinzufügen>Neues Projekt aus.
2. Wählen Sie die Vorlage "xUnit Test Project " und dann "Weiter" aus.
3. Benennen Sie das Projekt Functions.Tests.
Entfernen Sie die Standardtestdateien aus dem Projekt Functions.Tests .
Verwenden Sie NuGet, um einen Verweis aus der Test-App zu Microsoft.AspNetCore.Mvc hinzuzufügen. Sie können die Paket-Manager-Konsole verwenden oder die folgenden Schritte ausführen:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt Functions.Tests , und wählen Sie dann "NuGet-Pakete verwalten" aus.
2. Suchen und installieren Sie Microsoft.AspNetCore.Mvc.
Fügen Sie in der Functions.TestsAppeinen Verweis auf die Functions-App hinzu:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt Functions.Tests, und wählen Sie dann"Projektverweis> aus.
2. Wählen Sie das Projekt "Funktionen" und dann "OK" aus.

Schritt 2: Erstellen von Testklassen

In diesem Abschnitt erstellen Sie die Klassen, die Sie zum Ausführen der automatisierten Tests verwenden.

Jede Funktion verwendet eine Implementierung von ILogger, um die Nachrichtenprotokollierung zu handhaben. Bei einigen Tests werden keine Nachrichten protokolliert, oder es spielt keine Rolle, wie die Protokollierung implementiert wird. Andere Tests müssen protokollierte Nachrichten auswerten, um festzustellen, ob ein Test bestanden werden soll.

Erstellen Sie eine Klasse in Ihrem Functions.Tests-Projekt namens NullScope , und fügen Sie den folgenden Code hinzu. Diese Klasse stellt einen simulierten Bereich bereit. In einem späteren Schritt erstellen Sie eine Implementierung von ILogger, die diesen Bereich verwendet.
```
using System;

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

        private NullScope() { }

        public void Dispose() { }
    }
}
```
Erstellen Sie eine Klasse in Ihrem Functions.Tests-Projekt namens ListLogger , und fügen Sie den folgenden Code hinzu. Diese Klasse verwaltet eine interne Liste von Nachrichten, die während des Tests ausgewertet werden sollen. Um die erforderliche ILogger Schnittstelle zu implementieren, verwendet die Klasse den Simulierten Bereich aus der NullScope Klasse. Die Testfälle übergeben den Pseudobereich an die ListLogger Klasse.
```
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 Member, wie von der ILogger Schnittstelle vertraglich vereinbart:
- BeginScope: Geltungsbereiche fügen Ihrer Protokollierung Kontext hinzu. In diesem Fall verweist der Test auf die statische Instanz der NullScope Klasse, damit der Test funktioniert.
- IsEnabled: Es wird ein Standardwert false angegeben.
- Log: Diese Methode verwendet die bereitgestellte formatter Funktion, um die Nachricht zu formatieren. Die Methode fügt dann den resultierenden Text der Logs Auflistung hinzu.
Die Logs-Auflistung ist eine Instanz von List<string> und wird im Konstruktor initialisiert.
Erstellen Sie eine Codedatei im Projekt Functions.Tests namens LoggerTypes.cs , und fügen Sie den folgenden Code hinzu:
```
namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}
```
Diese Aufzählung gibt den Loggertyp an, den die Tests verwenden.

Erstellen Sie eine Klasse im Projekt Functions.Tests namens TestFactory , und fügen Sie den folgenden 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", "Bernardo" },
                new object[] { "name", "Ananya" },
                new object[] { "name", "Vlad" }

            };
        }

        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üsselwertpaare stellen Werte dar, die an eine Abfragezeichenfolge übergeben werden.
CreateDictionary: Diese Methode akzeptiert ein Schlüssel-Wert-Paar als Argument. Es wird eine neue Instanz von Dictionary zurückgegeben, die verwendet wird, um eine Instanz von QueryCollection zu erstellen, um Abfragezeichenfolgenwerte darzustellen.
CreateHttpRequest: Diese Methode erstellt eine HTTP-Anforderung, die mit den angegebenen Abfragezeichenfolgenparametern initialisiert wird.
CreateLogger: Diese Methode gibt eine Implementierung von ILogger zurück, die zum Testen verwendet wird. Die ILogger Implementierung hängt vom angegebenen Loggertyp ab. Wenn ein Listentyp angegeben ist, verfolgt die ListLogger Instanz protokollierte Nachrichten, die für die Auswertung in Tests verfügbar sind.

Erstellen Sie eine Klasse im Projekt Functions.Tests namens FunctionsTests , und fügen Sie den folgenden 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", "Bernardo");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bernardo. 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 Klasse implementiert die folgenden Elemente:

Http_trigger_should_return_known_string: Dieser Test verwendet den Abfragezeichenfolgenwert name=Bernardo , um eine Anforderung an eine HTTP-Funktion zu erstellen. Dieser Test ü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. Nachdem die Funktion ausgeführt wurde, wird das Protokoll überprüft, um sicherzustellen, dass die erwartete Nachricht vorhanden ist.

Um in Ihren Tests auf Anwendungseinstellungen zuzugreifen, können Sie eine Implementierung mit simulierten Umgebungsvariablenwerten in Ihre Funktion IConfiguration.

Schritt 3: Ausführen von Tests

Um die Tests in Visual Studio auszuführen, wählen Sie Anzeigen>Test-Explorer aus. Wählen Sie im Test-Explorer "Alle Tests in der Ansicht ausführen>" aus.

Screenshot von Visual Studio. Der Test-Explorer zeigt, dass fünf Tests bestanden wurden. Im Projektmappen-Explorer sind die Projekte

Schritt 4: Debugtests

Um die Tests zu debuggen, legen Sie einen Haltepunkt für einen Test fest. Wählen Sie im Test-Explorer"Ausführen">"Zuletzt durchgeführten Debugvorgang ausführen" aus.

Lokales Entwickeln von Azure-Funktionen mithilfe von Core Tools

Leitfaden zum In-Process-Modell in C#

Leitfaden zum isolierten Workermodell in C#

Feedback

War diese Seite hilfreich?

Last updated on 2025-09-23