Delen via


Ontwikkel Azure Functions met Visual Studio

Visual Studio biedt een manier om C#-klassebibliotheekfuncties te ontwikkelen, testen en implementeren in Azure. Als deze ervaring uw eerste ervaring is met Azure Functions, raadpleegt u het overzicht van Azure Functions.

Om meteen aan de slag te gaan, overweeg de Quickstart voor Functies in Visual Studio te voltooien.

In dit artikel vindt u gedetailleerde informatie over het gebruik van Visual Studio voor het ontwikkelen van C#-klassebibliotheekfuncties en het publiceren ervan naar Azure. Er zijn twee modellen voor het ontwikkelen van C#-klassenbibliotheekfuncties: het geïsoleerde werkrolmodel en het procesmodel.

Je leest de versie van het geïsoleerde werkermodel van dit artikel. U kunt het gewenste model bovenaan het artikel selecteren.

Je leest de lopende modelversie van dit artikel. U kunt het gewenste model bovenaan het artikel selecteren.

Tenzij anders vermeld, zijn procedures en voorbeelden weergegeven voor Visual Studio 2022. Zie de releaseopmerkingen of de opmerkingen bij de preview-release voor meer informatie over Visual Studio 2022-releases.

Vereiste voorwaarden

  • Visual Studio 2022, inclusief de Azure development werklast.

  • Andere resources die u nodig hebt, zoals een Azure Storage-account, worden tijdens het publicatieproces in uw abonnement gemaakt.

  • Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

Maak een Azure Functions-project aan

De Azure Functions-projectsjabloon in Visual Studio maakt een C#-classbibliotheekproject dat je in een function-app in Azure kunt publiceren. U kunt een function app gebruiken om functies te groeperen als een logische eenheid voor eenvoudigere beheer, implementatie, schaalvergroting en het delen van middelen.

  1. Selecteer uit het Visual Studio-menu Bestand>Nieuw>Project.

  2. Voer in het dialoogvenster Een nieuw project makenfuncties in het zoekvak in, selecteer de Azure Functions-sjabloon en selecteer vervolgens Volgende.

  3. Voer in het dialoogvenster Uw nieuwe project configureren voor projectnaam een naam in voor uw project en selecteer vervolgens Volgende. De naam van de function app moet geldig zijn als een C# namespace, gebruik daarom geen underscores, streepjes of andere niet-alfanumerieke tekens.

  4. Voer in het dialoogvenster Aanvullende informatie de acties uit die worden vermeld in de volgende tabel:

    Instelling Handeling Beschrijving
    Functions-werkrol Selecteer .NET 8.0 Geïsoleerd (langetermijnondersteuning). Visual Studio maakt een functieproject dat wordt uitgevoerd in een geïsoleerd werkproces. Het geïsoleerde werkproces ondersteunt ook andere versies van .NET en .NET Framework die geen langetermijnondersteuning (LTS) bieden. Voor meer informatie, zie Azure Functions runtime versions overview.
    Function Selecteer HTTP-trigger. Visual Studio maakt een functie die wordt geactiveerd door een HTTP-aanvraag.
    Azurite gebruiken voor runtime-opslagaccount (AzureWebJobsStorage) Schakel dit selectievakje in. Omdat een functie-app in Azure een opslagaccount vereist, wordt er een toegewezen of aangemaakt wanneer u uw project naar Azure publiceert. Een HTTP-trigger maakt geen gebruik van een verbindingsreeks voor een opslagaccount. Voor alle andere triggertypen is een geldige verbindingsreeks voor het opslagaccount vereist.
    Autorisatieniveau Selecteer Anoniem. Wanneer u deze autorisatie-instelling gebruikt, kan elke client de gemaakte functie activeren zonder een sleutel op te geven. Met deze configuratie kunt u uw nieuwe functie eenvoudig testen. Voor meer informatie, zie Authorization level.

    Schermopname van het dialoogvenster Aanvullende informatie van Visual Studio waarin geconfigureerde instellingen worden weergegeven, zoals een geïsoleerde .NET-versie voor de Functions-werkrol.

    Instelling Handeling Beschrijving
    Functions-werkrol Selecteer .NET 8.0 In-process (langetermijnondersteuning). Visual Studio maakt een functieproject dat in uitvoering wordt uitgevoerd met versie 4.x van de Functions-runtime. Voor meer informatie, zie Azure Functions runtime versions overview.
    Function Selecteer HTTP-trigger. Visual Studio maakt een functie die wordt geactiveerd door een HTTP-aanvraag.
    Azurite gebruiken voor runtime-opslagaccount (AzureWebJobsStorage) Schakel dit selectievakje in. Omdat een functie-app in Azure een opslagaccount vereist, wordt er een toegewezen of aangemaakt wanneer u uw project naar Azure publiceert. Een HTTP-trigger maakt geen gebruik van een verbindingsreeks voor een opslagaccount. Voor alle andere triggertypen is een geldige verbindingsreeks voor het opslagaccount vereist.
    Autorisatieniveau Anoniem selecteren Wanneer u deze autorisatie-instelling gebruikt, kan elke client de gemaakte functie activeren zonder een sleutel op te geven. Met deze configuratie kunt u uw nieuwe functie eenvoudig testen. Voor meer informatie, zie Authorization level.

    Schermopname van het dialoogvenster Aanvullende informatie van Visual Studio waarin geconfigureerde instellingen worden weergegeven, zoals een in-process .NET-versie voor de Functions-werkrol.

    Zorg ervoor dat je het Authorization level instelt op Anonymous. Als u het standaardniveau van de functie selecteert, moet u de functiesleutel presenteren in aanvragen voor toegang tot uw functie-eindpunt.

  5. Selecteer Create om het functieproject en de HTTP-triggerfunctie te maken.

Nadat u een Functions-project hebt gemaakt, maakt de projectsjabloon een C#-project, installeert u de Microsoft.Azure.Functions.Worker en Microsoft.Azure.Functions.Worker.Sdk NuGet-pakketten en stelt u het doelframework in.

Nadat u een Functions-project hebt gemaakt, maakt de projectsjabloon een C#-project, installeert u het Microsoft.NET.Sdk.Functions NuGet-pakket en stelt u het doelframework in.

Het nieuwe project heeft de volgende bestanden:

  • host.json: dit bestand biedt een manier om de Functions-host te configureren. Deze instellingen zijn van toepassing zowel bij lokaal draaien als in Azure. Voor meer informatie, zie host.json referentie.

  • local.settings.json: dit bestand onderhoudt instellingen die u gebruikt wanneer u functies lokaal uitvoert. Deze instellingen worden niet gebruikt wanneer uw app wordt uitgevoerd in Azure. Zie Werken met app-instellingen lokaal voor meer informatie.

    Belangrijk

    Omdat het local.settings.json bestand geheimen kan bevatten, moet u het uitsluiten van het broncodebeheer van uw project. Controleer in het dialoogvenster Eigenschappen van dit bestand of de instelling Kopiëren naar Uitvoermap is ingesteld op Kopiëren als nieuwer.

Zie projectstructuur in de geïsoleerde werkergids voor meer informatie.

Voor meer informatie, zie Functions class library project.

Werk lokaal met app-instellingen

Wanneer uw functie-app wordt uitgevoerd in Azure, worden de instellingen die door uw functies zijn vereist, versleuteld opgeslagen in app-instellingen. Tijdens lokale ontwikkeling worden deze instellingen in plaats daarvan toegevoegd aan de Values verzameling in het local.settings.json-bestand . Het bestandlocal.settings.json slaat ook instellingen op die worden gebruikt door lokale ontwikkelhulpprogramma's.

Items in de verzameling in het Valueslocal.settings.json-bestand van uw project zijn bedoeld om items in de toepassingsinstellingen van uw functie-app in Azure te spiegelen.

Visual Studio uploadt de instellingen niet automatisch in local.settings.json wanneer u het project publiceert. Om ervoor te zorgen dat deze instellingen ook in je functie-app in Azure bestaan, upload ze nadat je je project hebt gepubliceerd. Voor meer informatie, zie Functie-app-instellingen. De waarden in een ConnectionStrings verzameling worden niet gepubliceerd.

Uw code kan de functie-app-instellingswaarden ook lezen als omgevingsvariabelen. Zie Omgevingsvariabelen voor meer informatie.

Configureer het project voor lokale ontwikkeling

De Functions-runtime maakt intern gebruik van een opslagaccount. Tijdens de ontwikkeling kunt u een geldig opslagaccount gebruiken voor dit interne account of u kunt de Azurite-emulator gebruiken.

Voor alle andere triggertypen dan HTTP en webhooks moet u de waarde van de Values.AzureWebJobsStorage sleutel instellen in het local.settings.json-bestand :

  • Stel voor een opslagaccount de waarde in op de verbindingsreeks van uw opslagaccount.
  • Stel voor de emulator de waarde in op UseDevelopmentStorage=true.

Als u de emulator gebruikt, wijzigt u deze instelling in een werkelijke verbindingsreeks voor het opslagaccount vóór de implementatie. Zie Lokale opslagemulator voor meer informatie.

Voer de volgende stappen uit om de verbindingsreeks voor het opslagaccount in te stellen:

  1. Meld u aan bij Azure Portal en ga vervolgens naar uw opslagaccount.

  2. Selecteer Beveiliging en>. Kopieer onder key1 de waarde van de verbindingsreeks .

  3. Open het local.settings.json-bestand in uw Visual Studio-project. Stel de waarde van de AzureWebJobsStorage sleutel in op de verbindingsreeks die u hebt gekopieerd.

  4. Herhaal de vorige stap om unieke sleutels toe te voegen aan de Values array voor eventuele andere connecties die door uw functies vereist zijn.

Voeg een functie toe aan je project

In C#-klassebibliotheekfuncties worden de bindingen die door de functies worden gebruikt gedefinieerd door kenmerken in de code toe te passen. Wanneer je je functietriggers uit de beschikbare sjablonen maakt, worden de triggerattributen voor je toegepast.

  1. In Solution Explorer klikt u met de rechtermuisknop op uw projectknooppunt en selecteert u Toevoegen>Nieuwe Azure-functie.

  2. Selecteer Azure Function in het dialoogvenster Nieuw item toevoegen en selecteer vervolgens Toevoegen.

  3. Selecteer een trigger en stel vervolgens de vereiste bindingseigenschappen in. Als u een Opslagservicetrigger selecteert en u de verbinding wilt configureren, schakelt u het selectievakje in voor het configureren van de triggerverbinding. In het volgende voorbeeld ziet u de instellingen voor het maken van een wachtrijopslagtriggerfunctie.

    Schermopname van het dialoogvenster Nieuwe Azure-functie voor een wachtrijtrigger, waarbij de naam van de verbindingsreeks is ingesteld op QueueStorage en de wachtrij op myqueue-items.

  4. Selecteer Toevoegen. Als u het selectievakje voor het configureren van een opslagverbinding in de vorige stap inschakelt, wordt de pagina Verbinding maken met afhankelijkheid weergegeven. Selecteer een Azurite-opslagemulator of Azure Storage en selecteer vervolgens Volgende.

    • Als u een Azurite-opslagemulator selecteert, verschijnt de pagina Verbinding maken met de Azurite-opslagemulator. Voer de volgende stappen uit:
      1. Kies Volgende.
      2. Selecteer Voltooien op de pagina Samenvatting van wijzigingen. Visual Studio configureert de afhankelijkheid en maakt de triggerklasse.
    • Als u Azure Storage selecteert, wordt de pagina Verbinding maken met Azure Storage weergegeven. Voer de volgende stappen uit:
      1. Selecteer een opslagaccount en klik vervolgens op Volgende. Visual Studio probeert verbinding te maken met uw Azure-account en een eindpunt op te halen.
      2. Kies Volgende.
      3. Selecteer Voltooien op de pagina Samenvatting van wijzigingen. Visual Studio configureert de afhankelijkheid en maakt de triggerklasse.

    Dit triggervoorbeeld gebruikt een applicatie-instelling voor de opslagverbinding met een sleutel genaamd QueueStorage. Deze sleutel, opgeslagen in het local.settings.json-bestand, verwijst naar de Emulator van De Azurite of een opslagaccount.

  5. Onderzoek de nieuw toegevoegde klasse. De volgende C#-klasse vertegenwoordigt bijvoorbeeld een eenvoudige queue Storage-triggerfunctie:

    Een Run() methode wordt toegeschreven aan Function. Deze eigenschap geeft aan dat de methode het toegangspunt voor de functie is.

    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);
        }
    }
    

    Een statische Run() methode wordt toegeschreven aan FunctionName. Deze eigenschap geeft aan dat de methode het toegangspunt voor de functie is.

    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}");
            }
        }
    }
    

Een binding-specifiek attribuut wordt toegepast op elke bindingparameter die aan de toegangspuntmethode wordt geleverd. Het attribuut neemt de bindinformatie als parameters.

In de voorgaande code heeft de eerste parameter een QueueTrigger kenmerk toegepast, wat aangeeft dat het een Queue Storage-triggerfunctie betreft. De naam van de wachtrij en de naam van de verbindingsreinstelling worden als parameters doorgegeven aan het QueueTrigger attribuut. In uw klas:

  • De parameter voor de wachtrijnaam moet overeenkomen met de naam van de wachtrij die u in een eerdere stap gebruikt om de trigger te maken, zoals myqueue-items.
  • De naam van de instelling van de verbindingsreeks moet overeenkomen met de naam die u in een eerdere stap gebruikt om de trigger te maken, zoals QueueStorage.

Zie Azure Queue Storage-trigger voor Azure Functions voor meer informatie.

Gebruik de voorgaande procedure om meer functies toe te voegen aan uw functie-app-project. Elke functie in het project kan een andere trigger hebben, maar een functie moet precies één trigger hebben. Zie Azure Functions-triggers en -bindingen voor meer informatie.

Voeg bindings toe

Net zoals bij triggers worden input- en outputbindingen aan uw functie toegevoegd als bindingsattributen. Voer de volgende stappen uit om bindingen toe te voegen aan een functie:

  1. Zorg ervoor dat u het project configureert voor lokale ontwikkeling.

  2. Voeg het juiste NuGet-extensiepakket toe voor elke specifieke binding. Voor bindingsspecifieke NuGet-pakketvereisten, zie het naslagartikel voor de binding. Zie bijvoorbeeld Azure Event Hubs-triggers en -bindingen voor Azure Functions voor pakketvereisten voor de Azure Event Hubs-trigger.

  3. Gebruik de volgende opdracht in de Package Manager-console om een specifiek pakket te installeren:

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

    Vervang in deze code door <BINDING_TYPE> de specifieke naam van de bindingsextensie en vervang deze door <TARGET_VERSION> een specifieke versie van het pakket, zoals 4.0.0. Geldige versies worden vermeld op de individuele pakketpagina's op NuGet.org.

  4. Als er app-instellingen zijn die de binding nodig heeft, voegt u deze toe aan de Values verzameling in het lokale instellingsbestand.

    De functie gebruikt deze waarden wanneer hij lokaal wordt uitgevoerd. Wanneer de functie draait in de function app in Azure, maakt het gebruik van de instellingen van de function app. Met Visual Studio kunt u eenvoudig lokale instellingen publiceren naar Azure.

  5. Voeg het juiste koppelingsattribuut toe aan de methodehandtekening. In de volgende code activeert een wachtrijbericht de Run functie. De uitvoerbinding maakt vervolgens een nieuw wachtrijbericht met dezelfde tekst in een andere wachtrij.

     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;
        }
    }
    

    Het QueueOutput attribuut definieert de binding op de methode. Voor meerdere uitvoerbindingen plaatst u dit kenmerk in plaats daarvan op een tekenreekseigenschap van het geretourneerde object. Zie Meerdere uitvoerbindingen voor meer informatie.

    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;
        }
    }
    

    Het Queue-attribuut van de out-parameter definieert de uitvoerbinding.

    De verbinding met Queue Storage wordt verkregen via de QueueStorage instelling. Voor meer informatie, zie het referentieartikel voor de specifieke binding.

Voor een volledige lijst van de bindings die door Functies worden ondersteund, zie Supported bindings. Voor een completer voorbeeld van dit scenario, zie Connect functions to Azure Storage using Visual Studio.

Voer functies lokaal uit

U kunt Azure Functions Core Tools gebruiken om Functions-projecten uit te voeren op uw lokale ontwikkelcomputer. Wanneer u F5 selecteert om fouten in een Functions-project op te sporen, begint de lokale Functions-host (func.exe) te luisteren op een lokale poort (meestal 7071). Alle aanroepbare functie-eindpunten worden naar de uitvoer geschreven, en je kunt deze eindpunten gebruiken om je functies te testen. Zie Azure Functions lokaal ontwikkelen met Behulp van Core Tools voor meer informatie. Je wordt gevraagd om deze tools te installeren de eerste keer dat je een functie start vanuit Visual Studio.

Belangrijk

Vanaf versie 4.0.6517 van de Core Tools moeten in-process modelprojecten versie 4.5.0 of later van Microsoft.NET.Sdk.Functions gebruiken als referentie. Als u een eerdere versie gebruikt, genereert de func start opdracht een fout.

Voer de volgende stappen uit om uw functie in Visual Studio te starten in de foutopsporingsmodus:

  1. Selecteer F5. Als u hierom wordt gevraagd, accepteert u de aanvraag van Visual Studio om Azure Functions Core Tools te downloaden en te installeren. Mogelijk moet u ook een firewall-uitzondering inschakelen, zodat de hulpprogramma's HTTP-aanvragen kunnen verwerken.

  2. Wanneer het project wordt uitgevoerd, test u de code op dezelfde manier als u een geïmplementeerde functie test.

    Wanneer u Visual Studio in debug modus uitvoert, worden de breekpunten zoals verwacht geraakt.

Zie Testfuncties verderop in dit artikel voor een gedetailleerder testscenario dat gebruikmaakt van Visual Studio.

Publiceren naar Azure

Wanneer u uw Functions-project naar Azure publiceert, gebruikt Visual Studio zip-implementatie om de projectbestanden te implementeren. Indien mogelijk moet u ook Uitvoeren selecteren vanuit het pakketbestand , zodat het project wordt uitgevoerd in het implementatiepakket (.zip). Voor meer informatie, zie Run your functions from a package file in Azure.

Implementeer niet in Functions met behulp van Web Deploy (msdeploy).

Gebruik de volgende stappen om uw project te publiceren naar een functie-app in Azure:

  1. Klik in Solution Explorer met de rechtermuisknop op het project en selecteer Publiceren.

  2. Maak op de pagina Publiceren de volgende selecties:

    • Op Doel selecteer Azure, en selecteer Vervolgens Volgende.
    • Selecteer bij Specifiek doelde Azure-functie-app en selecteer vervolgens Volgende.
    • Selecteer nieuwe maken in het Functions-exemplaar.

    Schermopname van de pagina Publiceren. In de sectie Functions-exemplaar is een resourcegroep zichtbaar en Nieuw maken is gemarkeerd.

  3. Maak een nieuwe instantie aan met behulp van de waarden gespecificeerd in de volgende tabel:

    Instelling Waarde Beschrijving
    Naam Een wereldwijd unieke naam De naam moet uw nieuwe functie-app uniek identificeren. Accepteer de voorgestelde naam of voer een nieuwe naam in. De volgende tekens zijn geldig: a-z, 0-9en -.
    Abonnementsnaam De naam van uw abonnement De functie-app wordt gemaakt in een Azure-abonnement. Accepteer het standaardabonnement of selecteer een ander abonnement in de lijst.
    Resourcegroep De naam van uw resourcegroep De functieapp wordt gemaakt in een resource-groep. Selecteer Nieuw om een nieuwe resourcegroep te maken. U kunt ook een bestaande resourcegroep selecteren in de lijst.
    Abonnementstype Flexverbruik Wanneer u uw project publiceert naar een functie-app die wordt uitgevoerd in een Flex Consumption-abonnement, betaalt u mogelijk alleen voor uitvoeringen van uw functie-app. Andere hostingplannen kunnen hogere kosten met zich mee kunnen brengen.
    BELANGRIJK:
    Wanneer u een Flex Consumption-abonnement maakt, moet u eerst Een App Service-plan selecteren en vervolgens Flexverbruik opnieuw selecteren om een probleem met het dialoogvenster te wissen.
    Besturingssysteem Linux Voor het Flex Consumption-abonnement is momenteel Linux vereist.
    Plaats De locatie van de app-service Selecteer een locatie in een Azure-regio die wordt ondersteund door het Flex Consumption-abonnement. Wanneer een niet-ondersteunde regio is geselecteerd, wordt de knop Maken grijs weergegeven.
    Grootte van instantiegeheugen 2048 De geheugengrootte van de exemplaren van de virtuele machine waarin de app wordt uitgevoerd, is uniek voor het Flex Consumption-abonnement.
    Azure Storage Een opslagaccount voor algemeen gebruik Voor de Functions-runtime is een opslagaccount vereist. Selecteer Nieuw om een opslagaccount voor algemene doeleinden te configureren. U kunt ook een bestaand account gebruiken dat voldoet aan de vereisten voor het opslagaccount.
    Application Insights Een Application Insights-exemplaar Schakel Application Insights-integratie in voor uw functie-app. Selecteer Nieuw om een nieuwe instantie te maken, hetzij in een nieuwe of in een bestaande Log Analytics-werkruimte. U kunt ook een bestaand exemplaar gebruiken.

    Schermopname van het dialoogvenster Nieuwe functie-app maken. Velden voor de naam, het abonnement, de resourcegroep, het abonnement en andere instellingen worden ingevuld.

  4. Selecteer Maken om een function-app en de bijbehorende resources in Azure te maken. De status van middelencreatie wordt weergegeven in de linkerbenedenhoek van het venster.

  5. Klik op Voltooien. Het venster Voortgang van het maken van een publicatieprofiel wordt weergegeven. Wanneer het profiel is gemaakt, selecteert u Sluiten.

  6. Selecteer Publiceren op de pagina Publicatieprofiel om het pakket te implementeren dat uw projectbestanden bevat in uw nieuwe functie-app in Azure.

    Wanneer de implementatie is voltooid, wordt de hoofd-URL van de functie-app in Azure weergegeven op de publicatieprofielpagina.

  7. Ga op de publicatieprofielpagina naar de sectie Hosting . Selecteer het beletselteken (...) en selecteer vervolgens Openen in Azure Portal. De nieuwe functie-app Azure-bron wordt geopend in de Azure-portal.

    Schermopname van de publicatieprofielpagina. In de sectie Hosting is het snelmenu met het beletselteken geopend en is Openen in Azure Portal gemarkeerd.

Instellingen voor functie-app

Visual Studio uploadt geen app-instellingen automatisch wanneer u uw project publiceert. Als u instellingen toevoegt aan het local.settings.json-bestand , moet u deze ook toevoegen aan de functie-app in Azure.

De eenvoudigste manier om de vereiste instellingen te uploaden naar uw functie-app in Azure, is door ze te beheren in Visual Studio. Ga op de publicatieprofielpagina naar de sectie Hosting . Selecteer het beletselteken (...) en selecteer vervolgens Azure App Service-instellingen beheren.

Schermopname van de sectie Hosting van de publicatieprofielpagina. Het snelmenu met het beletselteken is geopend en Azure App Service-instellingen beheren is gemarkeerd.

Wanneer u de selectie maakt, wordt het dialoogvenster Toepassingsinstellingen geopend voor de functie-app. U kunt dit dialoogvenster gebruiken om toepassingsinstellingen toe te voegen of bestaande instellingen te wijzigen.

Schermopname van het dialoogvenster Toepassingsinstellingen met lokale en externe waarden voor verschillende instellingen en besturingselementen voor het toevoegen en bewerken van waarden.

Voor elke instelling is de lokale waarde de waarde in het bestandlocal.settings.json en is de externe waarde de waarde in de functie-app in Azure.

  • Als u een app-instelling wilt maken, selecteert u Instelling toevoegen.
  • Als u een instellingswaarde van het veld Lokaal naar het veld Extern wilt kopiëren, selecteert u Waarde invoegen in Lokaal.

Wachtende wijzigingen worden naar het lokale instellingenbestand en de functie-app geschreven wanneer u OK selecteert.

Notitie

Standaard wordt het local.settings.json-bestand niet ingecheckt in broncodebeheer. Als u als gevolg hiervan een lokaal Functions-project kloont vanuit broncodebeheer, heeft het project geen local.settings.json bestand. U moet het local.settings.json-bestand handmatig maken in de hoofdmap van het project, zodat het dialoogvenster Toepassingsinstellingen naar verwachting werkt.

Je kunt de applicatie-instellingen ook op een van de volgende manieren beheren:

Foutopsporing op afstand

Om uw function-app op afstand te debuggen, moet u een debugconfiguratie van uw project publiceren. U moet ook externe foutopsporing inschakelen in uw functie-app in Azure.

In deze sectie wordt ervan uitgegaan dat er een foutopsporingsconfiguratie voor uw functie-app wordt gepubliceerd.

Overwegingen bij het debuggen op afstand

  • Extern debuggen wordt niet aanbevolen op een productieservice.
  • Als u externe foutopsporing wilt gebruiken, moet u uw functie-app hosten in een Premium- of App Service-plan.
  • Externe foutopsporing wordt momenteel alleen ondersteund bij het uitvoeren van uw C#-app in Windows.
  • Als u de functie Just My Code hebt ingeschakeld in Visual Studio, schakelt u deze uit. Zie Just My Code in- of uitschakelen voor instructies.
  • Vermijd lange stops bij onderbrekingspunten wanneer u externe foutopsporing gebruikt. Wanneer een proces langer dan een paar minuten wordt gestopt, behandelt Azure het als een niet-reagerend proces en wordt het afgesloten.
  • Terwijl u foutopsporing uitvoert, verzendt de server gegevens naar Visual Studio, wat van invloed kan zijn op de bandbreedtekosten. Zie prijscalculator voor informatie over bandbreedtetarieven.
  • Externe foutopsporing wordt na 48 uur automatisch uitgeschakeld in uw functie-app. Daarna moet u externe foutopsporing weer inschakelen.

Bevestig de debugger

Wanneer u fouten opssport in een geïsoleerde werkproces-app, moet u het externe foutopsporingsprogramma momenteel koppelen aan een afzonderlijk .NET-proces. Er zijn ook verschillende andere configuratiestappen vereist.

Als u een extern foutopsporingsprogramma wilt koppelen aan een functie-app die in een proces wordt uitgevoerd, gescheiden van de Functions-host, voert u de volgende stappen uit:

  1. Ga op de publicatieprofielpagina naar de sectie Hosting . Selecteer het beletselteken (...) en selecteer vervolgens Het foutopsporingsprogramma bijvoegen.

    Visual Studio maakt verbinding met uw functie-app en schakelt externe foutopsporing in als deze nog niet is ingeschakeld.

    Notitie

    Omdat het externe foutopsporingsprogramma geen verbinding kan maken met het hostproces, wordt er mogelijk een foutbericht weergegeven. Hoe dan ook, het lokale foutopsporingsprogramma heeft geen toegang tot uw onderbrekingspunten en biedt u geen manier om variabelen te inspecteren of code te doorlopen.

  2. Selecteer In het menu Foutopsporing van Visual Studio de optie Bijvoegen aan proces.

  3. Voer in het dialoogvenster Bijvoegen aan proces de volgende stappen uit:

    1. Naast verbindingstype, selecteer Microsoft Azure App Services.
    2. Selecteer Zoeken naast verbindingsdoel.
  4. Zoek en selecteer uw functie-app in het dialoogvenster Azure Koppelen aan proces en selecteer deze. Selecteer vervolgens OK.

  5. Als daarom wordt gevraagd, sta Visual Studio toe toegang te verkrijgen via uw lokale firewall.

  6. Selecteer in het dialoogvenster Bijvoegen aan procesde optie Processen weergeven voor alle gebruikers. Selecteer dotnet.exeen selecteer vervolgens Bijvoegen.

    Schermopname van het dialoogvenster Bijvoegen aan proces. Het verbindingstype is Microsoft Azure App Services. In de procestabel is dotnet.exe geselecteerd.

Wanneer de bewerking is voltooid, bent u gekoppeld aan de C#-klassebibliotheekcode die wordt uitgevoerd in een geïsoleerd werkproces. Op dit punt kunt u uw functie-applicatie zoals gewoonlijk debuggen.

Als u een extern foutopsporingsprogramma wilt koppelen aan een functie-app die in het proces wordt uitgevoerd met de Functions-host, voert u de volgende stappen uit.

Ga op de publicatieprofielpagina naar de sectie Hosting . Selecteer het beletselteken (...) en selecteer vervolgens Het foutopsporingsprogramma bijvoegen.

Visual Studio maakt verbinding met uw functie-app en schakelt externe foutopsporing in als deze nog niet is ingeschakeld. Het foutopsporingsprogramma wordt ook gevonden en gekoppeld aan het hostproces voor de app. Op dit punt kunt u uw functie-applicatie zoals gewoonlijk debuggen.

Wanneer u klaar bent met foutopsporing, moet u externe foutopsporing uitschakelen.

Externe foutopsporing uitschakelen

Nadat u de externe foutopsporing van uw code hebt voltooid, moet u externe foutopsporing uitschakelen in Azure Portal. Externe foutopsporing wordt na 48 uur automatisch uitgeschakeld voor het geval u dit vergeet.

  1. Ga op de publicatieprofielpagina naar de sectie Hosting . Selecteer het beletselteken (...) en selecteer vervolgens Openen in Azure Portal. De Azure-portal wordt geopend voor de functie-app waarin uw project is geïmplementeerd.

  2. Selecteer in de functie-app Instellingenconfiguratie> en ga vervolgens naar het tabblad Algemene instellingen. Selecteer Uit naast Externe foutopsporing. Selecteer Opslaan en selecteer Vervolgens Doorgaan.

Nadat de functie-app opnieuw is gestart, kun je niet langer op afstand verbinding maken met je externe processen. U kunt hetzelfde tabblad in Azure Portal gebruiken om externe foutopsporing buiten Visual Studio in te schakelen.

Functies monitoren

De aanbevolen manier om uw functies te bewaken, is door uw functie-app te integreren met Application Insights. Schakel deze integratie in wanneer u uw functie-app maakt tijdens het publiceren van Visual Studio.

Als de integratie om een of andere reden niet is ingesteld tijdens het publiceren, moet u Application Insights-integratie voor uw functie-app in Azure nog steeds inschakelen.

Zie Uitvoeringsbewerkingen bewaken in Azure Functions voor meer informatie over het gebruik van Application Insights voor bewaking.

Testfuncties

In deze sectie wordt beschreven hoe u een C#-modelproject maakt dat u kunt testen met behulp van xUnit, een opensource-hulpprogramma voor het testen van eenheden voor .NET.

Stap 1: instellen

Volg deze stappen om de omgeving, inclusief het app-project en de functies, te configureren die nodig zijn om uw tests te ondersteunen:

  1. Maak in Visual Studio een Azure Functions-project met de naam Functions.

  2. Maak een HTTP-functie op basis van de sjabloon:

    1. Klik in Solution Explorer met de rechtermuisknop op het Functions-project en selecteer vervolgensNieuwe Azure-functie>.
    2. Selecteer Azure Function in het dialoogvenster Nieuw item toevoegen en selecteer vervolgens Toevoegen.
    3. Selecteer Http-trigger en selecteer vervolgens Toevoegen.
    4. Wijzig de naam van de nieuwe klasse MyHttpTrigger.
  3. Maak een timerfunctie op basis van de sjabloon:

    1. Klik in Solution Explorer met de rechtermuisknop op het Functions-project en selecteer vervolgensNieuwe Azure-functie>.
    2. Selecteer Azure Function in het dialoogvenster Nieuw item toevoegen en selecteer vervolgens Toevoegen.
    3. Selecteer Timertrigger en klik vervolgens op Toevoegen.
    4. Wijzig de naam van de nieuwe klasse MyTimerTrigger.
  4. Maak een xUnit Test-app in de oplossing:

    1. Klik in Solution Explorer met de rechtermuisknop op de oplossing die uw Functions-project bevat en selecteervervolgens Nieuw project>.
    2. Selecteer de sjabloon xUnit Test Project en selecteer vervolgens Volgende.
    3. Noem het project Functions.Tests.
  5. Verwijder de standaardtestbestanden uit het project Functions.Tests .

  6. Gebruik NuGet om een verwijzing uit de test-app toe te voegen aan Microsoft.AspNetCore.Mvc. U kunt Package Manager Console gebruiken of u kunt de volgende stappen uitvoeren:

    1. Klik in Solution Explorer met de rechtermuisknop op het project Functions.Tests en selecteer NuGet-pakketten beheren.
    2. Zoek en installeer Microsoft.AspNetCore.Mvc.
  7. Voeg in de app Functions.Testseen verwijzing toe naar de Functions-app :

    1. Klik in Solution Explorer met de rechtermuisknop op het project Functions.Tests en selecteer VervolgensProjectverwijzingtoevoegen>.
    2. Selecteer het Functions-project en selecteer vervolgens OK.

Stap 2: Testklassen maken

In deze sectie maakt u de klassen die u gebruikt om de geautomatiseerde tests uit te voeren.

Elke functie neemt een implementatie van ILogger om berichtlogboeken te beheren. In sommige tests worden er geen berichten geregistreerd of maakt het niet uit hoe logboekregistratie wordt geïmplementeerd. Andere tests moeten vastgelegde berichten evalueren om te bepalen of een test moet slagen.

  1. Maak een klasse in uw Functions.Tests-project met de naam NullScope en voeg de volgende code toe. Deze klasse biedt een mock scope. In een latere stap maakt u een implementatie van ILogger dat dit bereik gebruikt.

    using System;
    
    namespace Functions.Tests
    {
        public class NullScope : IDisposable
        {
            public static NullScope Instance { get; } = new NullScope();
    
            private NullScope() { }
    
            public void Dispose() { }
        }
    }
    
  2. Maak een klasse in uw Functions.Tests-project met de naam ListLogger en voeg de volgende code toe. Deze klasse onderhoudt een interne lijst met berichten die tijdens het testen moeten worden geëvalueerd. Voor het implementeren van de vereiste ILogger interface gebruikt de klasse het mock-bereik van de NullScope klasse. De testcases geven de mock scope door aan de ListLogger class.

    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);
            }
        }
    }
    

    De ListLogger klasse implementeert de volgende leden, zoals gecontracteerd door de ILogger interface:

    • BeginScope: Scopes geven context aan uw logregistratie. In dit geval verwijst de test naar het statische exemplaar van de NullScope klasse om de test te laten functioneren.
    • IsEnabled: Er wordt een standaardwaarde false opgegeven.
    • Log: Deze methode maakt gebruik van de opgegeven formatter functie om het bericht op te maken. De methode voegt vervolgens de resulterende tekst toe aan de Logs verzameling.

    De Logs collectie is een instantie van List<string> en wordt geïnitialiseerd in de constructor.

  3. Maak een codebestand in het Functions.Tests-project met de naam LoggerTypes.cs en voeg de volgende code toe:

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

    Met deze opsomming geeft u het type logger op dat door de tests wordt gebruikt.

  4. Maak een klasse in het Functions.Tests-project met de naam TestFactory en voeg de volgende code toe:

    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;
            }
        }
    }
    

    De TestFactory klasse implementeert de volgende leden:

    • Data: Met deze eigenschap wordt een IEnumerable verzameling voorbeeldgegevens geretourneerd. De sleutel-waardeparen vertegenwoordigen waarden die worden doorgegeven aan een queryreeks.
    • CreateDictionary: Deze methode accepteert een sleutel-waardepaar als argument. Het retourneert een nieuw exemplaar van Dictionary dat wordt gebruikt om een exemplaar te maken van QueryCollection om queryreekswaarden weer te geven.
    • CreateHttpRequest: Met deze methode maakt u een HTTP-aanvraag die wordt geïnitialiseerd met de opgegeven queryreeksparameters.
    • CreateLogger: Deze methode retourneert een implementatie van ILogger die wordt gebruikt voor het testen. De ILogger implementatie is afhankelijk van het gespecificeerde loggertype. Als er een lijsttype is opgegeven, houdt het ListLogger exemplaar geregistreerde berichten bij die beschikbaar zijn voor evaluatie in tests.
  5. Maak een klasse in het Functions.Tests-project met de naam FunctionsTests en voeg de volgende code toe:

    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);
            }
        }
    }
    

    Met deze klasse worden de volgende leden geïmplementeerd:

    • Http_trigger_should_return_known_string: Deze test gebruikt de waarde name=Bernardo van de querytekenreeks om een aanvraag voor een HTTP-functie te maken. Met deze test wordt gecontroleerd of het verwachte antwoord wordt geretourneerd.
    • Http_trigger_should_return_string_from_member_data: Deze test maakt gebruik van xUnit-kenmerken om voorbeeldgegevens aan de HTTP-functie te leveren.
    • Timer_should_log_message: Met deze test wordt een exemplaar gemaakt van ListLogger en doorgegeven aan een timerfunctie. Nadat de functie is uitgevoerd, wordt het logboek gecontroleerd om te controleren of het verwachte bericht aanwezig is.
  6. Voor toegang tot toepassingsinstellingen in uw tests kunt u een implementatie met gesimuleerde omgevingsvariabelewaarden in uw functie IConfiguration.

Stap 3: Tests uitvoeren

Als u de tests in Visual Studio wilt uitvoeren, selecteert uTest explorer weergeven>. Selecteer in Test Explorer, Uitvoeren>Alle tests uitvoeren in weergave.

Schermopname van Visual Studio. Test Explorer laat zien dat er vijf tests zijn geslaagd. In Solution Explorer zijn de Functions- en Functions.Test-projecten zichtbaar.

Stap 4: Foutopsporingstests

Als u fouten in de tests wilt opsporen, stelt u een onderbrekingspunt in voor een test. Selecteer in Test ExplorerRun>Debug Last Run.