Azure Functions ontwikkelen met Visual Studio

  • Artikel

Met Visual Studio kunt u C#-klassebibliotheekfuncties ontwikkelen, testen en implementeren in Azure. Als deze ervaring uw eerste ervaring is met Azure Functions, raadpleegt u Een inleiding tot Azure Functions.

Als u meteen aan de slag wilt gaan, kunt u overwegen om de quickstart voor Functions voor Visual Studio te voltooien.

Dit artikel bevat 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#-klassebibliotheekfuncties: het geïsoleerde werkrolmodel en het in-procesmodel.

In dit artikel leest u de geïsoleerde versie van het werkmodel. U kunt bovenaan het artikel uw voorkeursmodel kiezen.

U leest de in-process modelversie van dit artikel. U kunt bovenaan het artikel uw voorkeursmodel kiezen.

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.

Vereisten

  • Visual Studio 2022, met inbegrip van de Azure-ontwikkelworkload .

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

  • Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

Een Azure Functions-project maken

Met de Azure Functions-projectsjabloon in Visual Studio maakt u een C#-klassebibliotheekproject dat u kunt publiceren naar een functie-app in Azure. U kunt een functie-app gebruiken om functies te groeperen in een logische eenheid, zodat u resources eenvoudiger kunt beheren, implementeren, schalen en delen.

  1. Selecteer in Visual Studio-menu Bestand>Nieuw>Project.

  2. Voer in Een nieuw project makenfuncties in het zoekvenster in, kies de sjabloon Azure Functions en selecteer vervolgens Volgende.

  3. Voer in Uw nieuwe project configureren een projectnaam in voor uw project en selecteer vervolgens Maken. De functie-appnaam moet geldig zijn als een C#-naamruimte. Gebruik dus geen onderstrepingstekens, afbreekstreepjes of andere niet-alfanumerieke tekens.

  4. Gebruik de waarden in de volgende tabel voor de instellingen van Een nieuw Azure Functions-toepassing:

    Instelling Weergegeven als Beschrijving
    .NET-versie .NET 6 Geïsoleerd Met deze waarde maakt u een functieproject dat wordt uitgevoerd in een geïsoleerd werkproces. Geïsoleerde werkprocessen ondersteunen andere niet-LTS-versie van .NET en ook .NET Framework. Raadpleeg Overzicht van Azure Functions-runtime voor meer informatie.
    Functiesjabloon HTTP-trigger Met deze waarde wordt er een functie gemaakt die wordt geactiveerd door een HTTP-aanvraag.
    Opslagaccount (AzureWebJobsStorage) Opslagemulator Omdat een functie-app in Azure een opslagaccount vereist, wordt er een toegewezen of gemaakt wanneer u uw project publiceert naar Azure. Een HTTP-trigger gebruikt geen Azure Storage-accountverbindingsreeks. Alle andere triggers vereisen een geldige Azure Storage-accountverbindingsreeks.
    Verificatieniveau Anonieme De gemaakte functie kan door iedere client worden geactiveerd zonder een sleutel op te geven. Met deze autorisatie-instelling kunt u eenvoudig uw nieuwe functie testen. Raadpleeg Autorisatiesleutels in de HTTP- en webhookbindingen voor meer informatie over sleutels en autorisatie.

    Screenshot of Azure Functions project settings

    Instelling Weergegeven als Beschrijving
    .NET-versie .NET 6 Met deze waarde maakt u een functieproject dat in verwerking wordt uitgevoerd met versie 4.x van de Azure Functions-runtime. Raadpleeg Overzicht van Azure Functions-runtime voor meer informatie.
    Functiesjabloon HTTP-trigger Met deze waarde wordt er een functie gemaakt die wordt geactiveerd door een HTTP-aanvraag.
    Opslagaccount (AzureWebJobsStorage) Opslagemulator Omdat een functie-app in Azure een opslagaccount vereist, wordt er een toegewezen of gemaakt wanneer u uw project publiceert naar Azure. Een HTTP-trigger gebruikt geen Azure Storage-accountverbindingsreeks. Alle andere triggers vereisen een geldige Azure Storage-accountverbindingsreeks.
    Verificatieniveau Anonieme De gemaakte functie kan door iedere client worden geactiveerd zonder een sleutel op te geven. Met deze autorisatie-instelling kunt u eenvoudig uw nieuwe functie testen. Raadpleeg Autorisatiesleutels in de HTTP- en webhookbindingen voor meer informatie over sleutels en autorisatie.

    Screenshot of Azure Functions project settings

    Zorg ervoor dat u het Autorisatieniveau instelt op Anoniem. Wanneer u het standaardniveau van Functie kiest, moet u de functiesleutel opnemen in aanvragen om toegang te krijgen tot het eindpunt van de functie.

  5. Selecteer OK om het functieproject en de door HTTP geactiveerde functie te maken.

Nadat u een Azure 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 Azure 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: Hiermee kunt u de Functions-host configureren. Deze instellingen gelden zowel bij lokaal uitvoeren als in Azure. Zie host.json naslaginformatie voor meer informatie.

  • local.settings.json: onderhoudt instellingen die worden gebruikt bij het lokaal uitvoeren van functies. Deze instellingen worden niet gebruikt bij het uitvoeren in Azure. Zie het bestand Met lokale instellingen voor meer informatie.

    Belangrijk

    Omdat het bestand local.settings.json geheimen kan bevatten, moet u het uitsluiten van het broncodebeheer van uw project. Zorg ervoor dat de instelling Kopiëren naar uitvoermap voor dit bestand is ingesteld op Kopiëren als nieuwer.

Zie Projectstructuur in de handleiding Voor geïsoleerde werkrollen voor meer informatie.

Zie het functions-klassebibliotheekproject voor meer informatie.

Lokaal werken met app-instellingen

Wanneer u in een functie-app in Azure uitvoert, worden instellingen die vereist zijn voor uw functies veilig 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 bestand local.settings.json slaat ook instellingen op die worden gebruikt door lokale ontwikkelhulpprogramma's.

Items in de verzameling in het Values local.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. Als u er zeker van wilt zijn dat deze instellingen ook aanwezig zijn in uw functie-app in Azure, uploadt u deze nadat u uw project hebt gepubliceerd. Zie Instellingen voor de functie-app voor meer informatie. De waarden in een ConnectionStrings verzameling worden nooit gepubliceerd.

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

Het project configureren voor lokale ontwikkeling

De Functions-runtime maakt intern gebruik van een Azure Storage-account. Voor alle andere triggertypen dan HTTP en webhooks stelt u de Values.AzureWebJobsStorage sleutel in op een geldig Azure Storage-account verbindingsreeks. Uw functie-app kan ook de Azurite-emulator gebruiken voor de AzureWebJobsStorage verbindingsinstelling die voor het project is vereist. Als u de emulator wilt gebruiken, stelt u de waarde van AzureWebJobsStorage in op UseDevelopmentStorage=true. Wijzig deze instelling in een daadwerkelijk opslagaccount verbindingsreeks vóór de implementatie. Zie Lokale opslagemulator voor meer informatie.

Het opslagaccount instellen verbindingsreeks:

  1. Ga in Azure Portal naar uw opslagaccount.

  2. Kopieer op het tabblad Toegangssleutels onder Beveiliging en netwerken de Verbinding maken iontekenreeks van key1.

  3. Open het local.settings.json bestand in uw project en 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 matrix voor alle andere verbindingen die door uw functies zijn vereist.

Een functie toevoegen aan uw project

In C#-klassebibliotheekfuncties worden de bindingen die door de functie worden gebruikt, gedefinieerd door kenmerken in de code toe te passen. Wanneer u uw functietriggers maakt op basis van de opgegeven sjablonen, worden de triggerkenmerken voor u toegepast.

  1. Klik in Solution Explorer met de rechtermuisknop op het projectknooppunt en selecteer Nieuwe Azure-functie toevoegen>.

  2. Voer een naam in voor de klasse en selecteer Vervolgens Toevoegen.

  3. Kies uw trigger, stel de vereiste bindingseigenschappen in en selecteer vervolgens Toevoegen. In het volgende voorbeeld ziet u de instellingen voor het maken van een wachtrijopslagtriggerfunctie.

    Create a Queue storage trigger function

    Voor een Azure Storage-servicetrigger schakelt u het selectievakje Verbinding configureren in en wordt u gevraagd om te kiezen tussen het gebruik van een Azure-opslagemulator of het verwijzen naar een ingericht Azure-opslagaccount. Selecteer Volgende en als u een opslagaccount kiest, probeert Visual Studio verbinding te maken met uw Azure-account en de verbindingsreeks op te halen. Kies Opslaan verbindingsreeks waarde in het bestand Met lokale gebruikersgeheimen en vervolgens Voltooien om de triggerklasse te maken.

    In dit triggervoorbeeld wordt een toepassingsinstelling gebruikt voor de opslagverbinding met een sleutel met de naam QueueStorage. Deze sleutel, opgeslagen in het local.settings.json-bestand, verwijst naar de Emulator van De Azurite of een Azure-opslagaccount.

  4. Bekijk de zojuist toegevoegde klasse. De volgende C#-klasse vertegenwoordigt bijvoorbeeld een eenvoudige wachtrijopslagtriggerfunctie:

    U ziet een statische Run() methode die is toegeschreven aan Function. Dit kenmerk 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: {message.MessageText}");
        }
    }
}

    U ziet een statische Run() methode die is toegeschreven aan FunctionName. Dit kenmerk 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}");
        }
    }
}

Er wordt een bindingspecifiek kenmerk toegepast op elke bindingsparameter die wordt geleverd aan de invoerpuntmethode. Het kenmerk gebruikt de bindingsgegevens als parameters. In het vorige voorbeeld is voor de eerste parameter een QueueTrigger kenmerk toegepast, waarmee een wachtrijopslagtriggerfunctie wordt aangegeven. De naam van de wachtrij en verbindingsreeks instellingsnaam worden doorgegeven als parameters aan het QueueTrigger kenmerk. Zie Azure Queue Storage-bindingen voor Azure Functions voor meer informatie.

Gebruik de bovenstaande 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 Concepten van Azure Functions-triggers en -bindingen voor meer informatie.

Bindingen toevoegen

Net als bij triggers worden invoer- en uitvoerbindingen als bindingskenmerken aan uw functie toegevoegd. Voeg als volgt bindingen toe aan een functie:

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

  2. Voeg het juiste NuGet-extensiepakket voor de specifieke binding toe door de bindingspecifieke NuGet-pakketvereisten te vinden in het referentieartikel voor de binding. Zoek bijvoorbeeld naar pakketvereisten voor de Event Hubs-trigger in het naslagartikel over bindingen voor Event Hubs.

  3. Gebruik de volgende opdracht in de Pakketbeheer 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 dit voorbeeld door <BINDING_TYPE> de naam die specifiek is voor de bindingsextensie en <TARGET_VERSION> door een specifieke versie van het pakket, zoals 4.0.0. Geldige versies worden vermeld op de afzonderlijke 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 deze lokaal wordt uitgevoerd. Wanneer de functie wordt uitgevoerd in de functie-app in Azure, worden de instellingen van de functie-app gebruikt. Met Visual Studio kunt u eenvoudig lokale instellingen publiceren naar Azure.

  5. Voeg het juiste bindingskenmerk toe aan de methodehandtekening. In het volgende voorbeeld activeert een wachtrijbericht de functie en maakt de uitvoerbinding 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 kenmerk definieert de binding voor 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 kenmerk van de out parameter definieert de uitvoerbinding.

    De verbinding met Queue Storage wordt verkregen via de QueueStorage instelling. Zie het naslagartikel voor de specifieke binding voor meer informatie.

Zie Ondersteunde bindingen voor een volledige lijst met de bindingen die worden ondersteund door Functions.

Functies lokaal uitvoeren

Met Azure Functions Core-hulpprogramma's kunt u Azure Functions-projecten uitvoeren op uw lokale ontwikkelcomputer. Wanneer u op F5 drukt om fouten op te sporen in een Functions-project, begint de lokale Functions-host (func.exe) te luisteren op een lokale poort (meestal 7071). Aanroepbare functie-eindpunten worden naar de uitvoer geschreven en u kunt deze eindpunten gebruiken om uw functies te testen. Zie Werken met Azure Functions Core Tools voor meer informatie. U wordt gevraagd deze hulpprogramma's te installeren wanneer u voor het eerst een functie start vanuit Visual Studio.

Uw functie starten in Visual Studio in de foutopsporingsmodus:

  1. Druk op F5. Accepteer desgevraagd de aanvraag van Visual Studio om Azure Functions Core-hulpprogramma's (CLI) te downloaden en installeren. Mogelijk moet u ook een firewall-uitzondering inschakelen, zodat de hulpprogramma's HTTP-aanvragen kunnen afhandelen.

  2. Als het project wordt uitgevoerd, test u uw code zoals u een geïmplementeerde functie zou testen.

    Wanneer u Visual Studio uitvoert in de foutopsporingsmodus, worden onderbrekingspunten bereikt zoals verwacht.

Zie Testfuncties voor een gedetailleerder testscenario met 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 vanaf pakket selecteren, zodat het project wordt uitgevoerd in het implementatiepakket (.zip). Zie Uw functies uitvoeren vanuit een pakketbestand in Azure voor meer informatie.

Implementeer niet in Azure 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. Selecteer vervolgens Azure in Target en Vervolgens.

    Screenshot of publish window.

  2. Selecteer De Azure-functie-app (Windows) voor het specifieke doel, waarmee een functie-app wordt gemaakt die wordt uitgevoerd in Windows en selecteer vervolgens Volgende.

    Screenshot of publish window with specific target.

  3. Kies een nieuwe Azure-functie maken in het functie-exemplaar...

    Screenshot of create a new function app instance.

  4. Maak een nieuw exemplaar met behulp van de waarden die zijn opgegeven in de volgende tabel:

    Instelling Weergegeven als Beschrijving
    Naam Wereldwijd unieke naam Naam waarmee uw nieuwe functie-app uniek wordt aangeduid. Accepteer deze naam of voer een nieuwe in. Geldige tekens zijn a-z, 0-9 en -.
    Abonnement Uw abonnement Het te gebruiken Azure-abonnement. Accepteer dit abonnement of selecteer een nieuwe uit de vervolgkeuzelijst.
    Resourcegroep Naam van uw resourcegroep De resourcegroep waarin u uw functie-app wilt maken. Selecteer Nieuw om een nieuwe resourcegroep te maken. U kunt ook een bestaande resourcegroep kiezen in de vervolgkeuzelijst.
    Abonnemtsype Verbruik Wanneer u uw project publiceert in een functie-app die wordt uitgevoerd in een verbruiksabonnement, betaalt u alleen voor uitvoeringen van uw functie-app. Andere hostingabonnement kosten meer.
    Location Locatie van de app-service Kies een Locatie in een regio bij u in de buurt of in de buurt van andere services die door uw functies worden gebruikt.
    Azure Storage Storage-account voor algemeen gebruik Er is een Azure-opslagaccount vereist voor de Functions-runtime. Selecteer Nieuw om een algemeen opslagaccount te configureren. U kunt ook een bestaand account kiezen dat voldoet aan de vereisten voor een opslagaccount.
    Application Insights Application Insights-exemplaar Schakel Application Insights-integratie in voor uw functie-app. Selecteer Nieuw om een nieuw exemplaar te maken, in een nieuwe of in een bestaande Log Analytics-werkruimte. U kunt ook een bestaand exemplaar kiezen.

    Screenshot of Create App Service dialog.

  5. Selecteer Maken om een functie-app en de bijbehorende resources te maken in Azure. De status van het maken van resources wordt linksonder in het venster weergegeven.

  6. Zorg ervoor dat het uitvoeren vanuit het pakketbestand is ingeschakeld in het Functions-exemplaar. Uw functie-app wordt geïmplementeerd met Zip-implementeren met de modus Uitvoeren vanuit pakket ingeschakeld. Zip Deploy is de aanbevolen implementatiemethode voor uw functions-project, wat resulteert in betere prestaties.

    Screenshot of Finish profile creation.

  7. Selecteer Voltooien en selecteer op de pagina Publiceren de optie Publiceren om het pakket met uw projectbestanden te implementeren in de nieuwe functie-app in Azure.

    Nadat de implementatie is voltooid, wordt de hoofd-URL van de functie-app in Azure weergegeven op het tabblad Publiceren .

  8. Kies Openen in Azure Portal op het tabblad Publiceren in de sectie Hosting. Hiermee opent u de nieuwe Azure-resource voor de functie-app in Azure Portal.

    Screenshot of Publish success message.

Instellingen voor functie-app

Visual Studio uploadt deze instellingen niet automatisch wanneer u het project publiceert. Alle instellingen die u in de local.settings.json toevoegt, moet u ook toevoegen aan de functie-app in Azure.

De eenvoudigste manier om de vereiste instellingen naar uw functie-app in Azure te uploaden, is door de drie puntjes naast de sectie Hosting uit te vouwen en de koppeling Azure-app Service-instellingen beheren te selecteren die wordt weergegeven nadat u uw project hebt gepubliceerd.

Settings in Publish window

Als u deze koppeling selecteert, wordt het dialoogvenster Toepassingsinstellingen voor de functie-app weergegeven, waar u nieuwe toepassingsinstellingen kunt toevoegen of bestaande kunt wijzigen.

Application settings

Lokaal geeft een instellingswaarde weer in het bestand local.settings.json en Extern geeft een huidige instellingswaarde weer in de functie-app in Azure. Kies Instelling Toevoegen om een nieuwe app-instelling te maken. Gebruik de waarde Invoegen vanuit de lokale koppeling om een instellingswaarde naar het veld Extern te kopiëren. Wijzigingen die in behandeling zijn, worden naar het bestand met lokale instellingen en de functie-app geschreven wanneer u OK selecteert.

Notitie

Standaard wordt het local.settings.json-bestand niet ingecheckt in broncodebeheer. Dit betekent dat als u een lokaal Functions-project kloont vanuit broncodebeheer, het project geen local.settings.json-bestand heeft. In dit geval moet u het local.settings.json-bestand handmatig maken in de hoofdmap van het project, zodat het dialoogvenster Toepassingsinstellingen naar verwachting werkt.

U kunt ook toepassingsinstellingen op een van de volgende manieren beheren:

Foutopsporing op afstand

Als u op afstand fouten wilt opsporen in uw functie-app, moet u een foutopsporingsconfiguratie van uw project publiceren. U moet ook externe foutopsporing inschakelen in uw functie-app in Azure.

In deze sectie wordt ervan uitgegaan dat u al naar uw functie-app hebt gepubliceerd met behulp van een releaseconfiguratie.

Overwegingen voor foutopsporing op afstand

  • Externe foutopsporing wordt niet aanbevolen voor een productieservice.
  • Als Just My Code-foutopsporing is ingeschakeld, schakelt u deze uit.
  • Vermijd lange stops bij onderbrekingspunten bij externe foutopsporing. Azure behandelt een proces dat langer dan een paar minuten is gestopt als een niet-reagerend proces en wordt afgesloten.
  • Terwijl u foutopsporing uitvoert, verzendt de server gegevens naar Visual Studio, wat van invloed kan zijn op de bandbreedtekosten. Zie Azure-prijzen voor meer informatie over bandbreedtetarieven.
  • Externe foutopsporing wordt na 48 uur automatisch uitgeschakeld in uw functie-app. Na 48 uur moet u externe foutopsporing opnieuw inschakelen.

Het foutopsporingsprogramma koppelen

De manier waarop u het foutopsporingsprogramma koppelt, is afhankelijk van de uitvoeringsmodus. Wanneer u fouten opspoort in een geïsoleerde werkproces-app, moet u het externe foutopsporingsprogramma momenteel koppelen aan een afzonderlijk .NET-proces en zijn er verschillende andere configuratiestappen vereist.

Wanneer u klaar bent, moet u externe foutopsporing uitschakelen.

Een extern foutopsporingsprogramma koppelen aan een functie-app die in een proces wordt uitgevoerd, gescheiden van de Functions-host:

  1. Selecteer op het tabblad Publiceren het beletselteken (...) in de sectie Hosting en kies Publicatieprofiel downloaden. Met deze actie wordt een kopie van het publicatieprofiel gedownload en wordt de downloadlocatie geopend. U hebt dit bestand nodig, dat de referenties bevat die worden gebruikt om te koppelen aan uw geïsoleerde werkproces dat wordt uitgevoerd in Azure.

    Let op

    Het .publishsettings-bestand bevat uw referenties (niet-gecodeerd) die worden gebruikt om uw functie-app te beheren. De aanbevolen beveiligingsprocedures voor dit bestand zijn om het tijdelijk buiten uw bronmappen op te slaan (bijvoorbeeld in de map Bibliotheken\Documenten) en het vervolgens te verwijderen nadat het niet meer nodig is. Een kwaadwillende gebruiker die toegang krijgt tot het .publishsettings-bestand, kan uw functie-app bewerken, maken en verwijderen.

  2. Selecteer opnieuw op het tabblad Publiceren het beletselteken (...) in de sectie Hosting en kies vervolgens Het foutopsporingsprogramma bijvoegen.

    Screenshot of attaching the debugger from Visual Studio.

    Visual Studio maakt verbinding met uw functie-app en schakelt externe foutopsporing in, indien dit nog niet is ingeschakeld.

    Notitie

    Omdat het externe foutopsporingsprogramma geen verbinding kan maken met het hostproces, ziet u een fout. In elk geval breekt de standaardopsporing niet in uw code in.

  3. Kopieer in Visual Studio de URL voor de site onder Hosting op de pagina Publiceren.

  4. Selecteer Bijvoegen aan proces in het menu Foutopsporing en plak in het venster Bijvoegen aan proces de URL in het Verbinding maken iondoel, verwijder https:// en voeg de poort :4024toe.

    Controleer of uw doel eruitziet <FUNCTION_APP>.azurewebsites.net:4024 en druk op Enter.

    Visual Studio attach to process dialog

  5. Als u hierom wordt gevraagd, staat u Visual Studio toegang toe via uw lokale firewall.

  6. Wanneer u om referenties wordt gevraagd, kiest u in plaats van lokale gebruikersreferenties een ander account (meer opties in Windows). Geef de waarden op van userName en userPWD uit het gepubliceerde profiel voor e-mailadres en wachtwoord in het verificatiedialoogvenster in Windows. Nadat een beveiligde verbinding tot stand is gebracht met de implementatieserver, worden de beschikbare processen weergegeven.

    Visual Studio enter credential

  7. Controleer het proces Weergeven van alle gebruikers en kies vervolgens dotnet.exe en selecteer Bijvoegen. Wanneer de bewerking is voltooid, bent u gekoppeld aan de C#-klassebibliotheekcode die wordt uitgevoerd in een geïsoleerd werkproces. Op dit moment kunt u fouten opsporen in uw functie-app als normaal.

Een extern foutopsporingsprogramma koppelen aan een functie-app die in het proces wordt uitgevoerd met de Functions-host:

  • Selecteer op het tabblad Publiceren de weglatingstekens (...) in de sectie Hosting en kies vervolgens Het foutopsporingsprogramma bijvoegen.

    Screenshot of attaching the debugger from Visual Studio.

Visual Studio maakt verbinding met uw functie-app en schakelt externe foutopsporing in, indien dit nog niet is ingeschakeld. Het foutopsporingsprogramma wordt ook gevonden en gekoppeld aan het hostproces voor de app. Op dit moment kunt u fouten opsporen in uw functie-app als normaal.

Externe foutopsporing uitschakelen

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

  1. Selecteer op het tabblad Publiceren in uw project het beletselteken (...) in de sectie Hosting en kies Openen in Azure Portal. Met deze actie wordt de functie-app in Azure Portal geopend waarop uw project is geïmplementeerd.

  2. Selecteer in de functie-app Configuratie onder instellingen, kies Algemeen Instellingen, stel Externe foutopsporing in op Uit en selecteer Opslaan en vervolgens Doorgaan.

Nadat de functie-app opnieuw is opgestart, kunt u geen externe verbinding meer maken met uw externe processen. U kunt hetzelfde tabblad in Azure Portal gebruiken om externe foutopsporing buiten Visual Studio in te schakelen.

Functies bewaken

De aanbevolen manier om de uitvoering van uw functies te bewaken, is door uw functie-app te integreren met Azure-toepassing 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 uitgevoerd tijdens het publiceren, moet u application Insights-integratie nog steeds inschakelen voor uw functie-app in Azure.

Zie Azure Functions bewaken voor meer informatie over bewaking met Application Insights.

Functies testen

In deze sectie wordt beschreven hoe u een C#-modelproject maakt dat u kunt testen met xUnit.

Testing Azure Functions with C# in Visual Studio

1. Installatie

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

  1. Een nieuwe Functions-app maken en deze een naam opgeven voor Functions
  2. Maak een HTTP-functie op basis van de sjabloon en geef deze de naam MyHttpTrigger.
  3. Maak een timerfunctie op basis van de sjabloon en geef deze de naam MyTimerTrigger.
  4. Maak een xUnit Test-app in de oplossing en noem deze Functions.Tests. Verwijder de standaardtestbestanden.
  5. NuGet gebruiken om een verwijzing uit de test-app toe te voegen aan Microsoft.AspNetCore.Mvc
  6. Verwijs naar de Functions-app vanuit de app Functions.Tests.

Nu de projecten zijn gemaakt, kunt u de klassen maken die worden gebruikt om de geautomatiseerde tests uit te voeren.

2. Testklassen maken

Elke functie neemt een exemplaar van het verwerken van ILogger berichtlogboekregistratie. Sommige tests registreren geen berichten of maken geen zorgen over hoe logboekregistratie wordt geïmplementeerd. Andere tests moeten berichten evalueren die zijn geregistreerd om te bepalen of een test wordt doorgegeven.

  1. Maak een klasse met de naam ListLogger, die een interne lijst met berichten bevat die tijdens het testen moeten worden geëvalueerd. Voor het implementeren van de vereiste ILogger interface heeft de klasse een bereik nodig. In de volgende klasse wordt een bereik gesimuleerd voor de testcases die aan de ListLogger klasse moeten worden doorgegeven.

  2. Maak een nieuwe klasse in uw Functions.Tests-project met de naam NullScope.cs en voeg deze code toe:

    using System;

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

        private NullScope() { }

        public void Dispose() { }
    }
}

  3. Maak een klasse in uw Functions.Tests-project met de naam ListLogger.cs en voeg deze code toe:

    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 als gecontracteerd door de ILogger interface:

    • BeginScope: Bereiken voegen context toe aan uw logboekregistratie. In dit geval verwijst de test alleen naar het statische exemplaar van de NullScope klasse om de test te laten functioneren.

    • IsEnabled: er wordt een standaardwaarde false opgegeven.

    • Logboek: Deze methode maakt gebruik van de opgegeven formatter functie om het bericht op te maken en voegt vervolgens de resulterende tekst toe aan de Logs verzameling.

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

  4. Maak een codebestand in het project Functions.Tests met de naam LoggerTypes.cs en voeg deze code toe:

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

    Deze opsomming geeft het type logger aan dat door de tests wordt gebruikt.

  5. Maak een klasse in functions.Tests-project met de naam TestFactory.cs en voeg deze 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", "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;
        }
    }
}

    De TestFactory klasse implementeert de volgende leden:

    • Gegevens: Deze eigenschap retourneert een IEnumerable verzameling voorbeeldgegevens. De sleutelwaardeparen vertegenwoordigen waarden die worden doorgegeven aan een queryreeks.

    • CreateDictionary: deze methode accepteert een sleutel-waardepaar als argumenten en retourneert een nieuw Dictionary gebruikt om queryreekswaarden weer te QueryCollection geven.

    • CreateHttpRequest: Met deze methode wordt een HTTP-aanvraag gemaakt die is geïnitialiseerd met de opgegeven queryreeksparameters.

    • CreateLogger: Op basis van het loggertype retourneert deze methode een loggerklasse die wordt gebruikt voor het testen. Hiermee ListLogger worden geregistreerde berichten bijgehouden die beschikbaar zijn voor evaluatie in tests.

  6. Maak een klasse in functions.Tests-project met de naam FunctionsTests.cs en voeg deze 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", "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);
        }
    }
}

    De leden die in deze klasse zijn geïmplementeerd, zijn:

    • Http_trigger_should_return_known_string: Met deze test wordt een aanvraag gemaakt met de queryreekswaarden van name=Bill een HTTP-functie en 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. Zodra de functie is uitgevoerd, wordt het logboek gecontroleerd om te controleren of het verwachte bericht aanwezig is.

  7. Voor toegang tot toepassingsinstellingen in uw tests kunt u een IConfiguration exemplaar met gesimuleerde omgevingsvariabelewaarden in uw functie injecteren.

3. Tests uitvoeren

Als u de tests wilt uitvoeren, gaat u naar Test Explorer en selecteert u Alle tests uitvoeren in weergave.

Testing Azure Functions with C# in Visual Studio

4. Foutopsporingstests

Als u fouten in de tests wilt opsporen, stelt u een onderbrekingspunt in voor een test, gaat u naar Test Explorer en selecteert u Laatste > uitvoering uitvoeren.

Volgende stappen

Zie Werken met Azure Functions Core Tools voor meer informatie over de Azure Functions Core Tools.

Handleiding voor C#-model in proces

C#-handleiding voor geïsoleerde werkrollen