Vývoj Azure Functions pomocí sady Visual Studio

Visual Studio poskytuje způsob, jak vyvíjet, testovat a nasazovat funkce knihovny tříd jazyka C# do Azure. Pokud je toto prostředí s Azure Functions vaše první, prohlédněte si přehled Azure Functions.

Pokud chcete začít hned, zvažte dokončení rychlého startu Functions pro Visual Studio.

Tento článek obsahuje podrobné informace o tom, jak pomocí sady Visual Studio vyvíjet funkce knihovny tříd jazyka C# a publikovat je do Azure. Existují dva modely pro vývoj funkcí knihovny tříd jazyka C#: izolovaný model pracovního procesu a model v procesu.

Čtete verzi modelu izolovaného pracovníka tohoto článku. Upřednostňovaný model můžete vybrat v horní části článku.

Čtete rozpracovanou verzi modelu tohoto článku. Upřednostňovaný model můžete vybrat v horní části článku.

Důležité

Podpora modelu v procesu končí 10. listopadu 2026. Doporučujeme migrovat vaše aplikace do izolovaného pracovního modelu.

Pokud není uvedeno jinak, jsou uvedené postupy a příklady pro Visual Studio 2022. Další informace o vydaných verzích sady Visual Studio 2022 najdete v poznámkách k verzi nebo poznámkách k verzi Preview.

Požadavky

Visual Studio 2022, včetně úlohy vývoje pro Azure
Během procesu publikování se ve vašem předplatném vytvoří další prostředky, které potřebujete, například účet Azure Storage.
Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.

Vytvoření projektu služby Azure Functions

Šablona projektu Azure Functions v sadě Visual Studio vytvoří projekt knihovny tříd jazyka C#, který můžete publikovat do aplikace funkcí v Azure. Aplikaci funkcí můžete použít k seskupení funkcí jako logické jednotky pro snadnější správu, nasazení, škálování a sdílení prostředků.

V nabídce sady Visual Studio vyberte Soubor>>
V dialogovém okně Vytvořit nový projekt zadejte do vyhledávacího pole funkce , vyberte šablonu Azure Functions a pak vyberte Další.
V dialogovém okně Konfigurovat nový projekt zadejte název projektu a pak vyberte Další. Název aplikace funkcí musí být platný jako obor názvů C#, takže nepoužívejte podtržítka, pomlčky nebo jiné nealfanumerické znaky.

V dialogovém okně Další informace proveďte akce uvedené v následující tabulce:

Nastavení	Činnost	Popis
Pracovní proces Functions	Vyberte izolované prostředí .NET 8.0 (dlouhodobá podpora).	Visual Studio vytvoří projekt funkce, který běží v izolovaném pracovním procesu. Izolovaný pracovní proces také podporuje jiné verze rozhraní .NET a .NET Framework, které nenabízí dlouhodobou podporu (LTS). Další informace najdete v přehledu verzí modulu runtime Azure Functions.
Function	Vyberte HTTP trigger.	Visual Studio vytvoří funkci aktivovanou požadavkem HTTP.
Použití Azurite pro účet úložiště runtime (AzureWebJobsStorage)	Zaškrtněte toto políčko.	Vzhledem k tomu, že funkční aplikace v Azure vyžaduje účet úložiště, jeden je přiřazen nebo vytvořen při publikování projektu do Azure. HTTP trigger nepoužívá připojovací řetězec účtu úložiště. Všechny ostatní typy triggerů vyžadují platný připojovací řetězec Storage účtu.
Úroveň autorizace	Vyberte Anonymní.	Při použití tohoto nastavení autorizace může každý klient aktivovat vytvořenou funkci bez poskytnutí klíče. Tato konfigurace usnadňuje testování nové funkce. Další informace najdete v tématu Úroveň autorizace.

Snímek obrazovky dialogového okna 'Další informace' sady Visual Studio, které zobrazuje nakonfigurovaná nastavení, jako je izolovaná verze .NET pro pracovní službu Functions.

Nastavení	Činnost	Popis
Pracovní proces Functions	Vyberte .NET 8.0 v procesu (dlouhodobá podpora).	Visual Studio vytvoří projekt funkcí, který běží v procesu s modulem runtime Functions verze 4.x. Další informace najdete v přehledu verzí modulu runtime Azure Functions.
Function	Vyberte HTTP trigger.	Visual Studio vytvoří funkci aktivovanou požadavkem HTTP.
Použití Azurite pro účet úložiště runtime (AzureWebJobsStorage)	Zaškrtněte toto políčko.	Vzhledem k tomu, že funkční aplikace v Azure vyžaduje účet úložiště, jeden je přiřazen nebo vytvořen při publikování projektu do Azure. HTTP trigger nepoužívá připojovací řetězec účtu úložiště. Všechny ostatní typy triggerů vyžadují platný připojovací řetězec Storage účtu.
Úroveň autorizace	Vybrat anonymní	Při použití tohoto nastavení autorizace může každý klient aktivovat vytvořenou funkci bez poskytnutí klíče. Tato konfigurace usnadňuje testování nové funkce. Další informace najdete v tématu Úroveň autorizace.

Ujistěte se, že jste nastavili úroveň autorizace na anonymní. Pokud vyberete výchozí úroveň funkce, budete muset předložit klíč funkce v požadavcích pro přístup ke koncovému bodu funkce.

Výběrem možnosti Vytvořit vytvořte projekt funkce a funkci triggeru HTTP.

Po vytvoření projektu Functions vytvoří šablona projektu projekt v jazyce C#, nainstaluje Microsoft.Azure.Functions.Worker balíčky NuGet a Microsoft.Azure.Functions.Worker.Sdk nastaví cílovou architekturu.

Po vytvoření projektu Functions vytvoří šablona projektu projekt v jazyce C#, nainstaluje Microsoft.NET.Sdk.Functions balíček NuGet a nastaví cílovou architekturu.

Nový projekt obsahuje následující soubory:

host.json: Tento soubor poskytuje způsob, jak nakonfigurovat hostitele služby Functions. Tato nastavení platí jak při místním spuštění, tak v Azure. Další informace najdete v host.json referenčních informacích.
local.settings.json: Tento soubor udržuje nastavení, která používáte při místním spouštění funkcí. Tato nastavení se nepoužívají, když vaše aplikace běží v Azure. Další informace najdete v tématu Práce s místním nastavením aplikace.

Důležité

Protože souborlocal.settings.json může obsahovat tajné kódy, musíte ho vyloučit ze správy zdrojového kódu projektu. V dialogovém okně Vlastnosti pro tento soubor se ujistěte, že je nastavení Kopírovat do výstupního adresáře nastaveno na kopírovat, pokud je novější.

Další informace naleznete v tématu Struktura projektu v izolovaném pracovním průvodci.

Další informace naleznete v Projektu knihovny tříd Functions.

Práce s místním nastavením aplikace

Když vaše aplikace funkcí běží v Azure, nastavení vyžadovaná vašimi funkcemi se uloží zašifrovaná v nastavení aplikace. Během místního vývoje se tato nastavení místo toho přidají do Values kolekce v souborulocal.settings.json . Soubor local.settings.json také ukládá nastavení používaná místními vývojářskými nástroji.

Položky v kolekci Values v souboru local.settings.json projektu mají zrcadlit položky v nastavení aplikace funkcí v Azure.

Visual Studio při publikování projektu automaticky nenahraje nastavení v local.settings.json . Abyste měli jistotu, že tato nastavení existují i ve vaší aplikaci funkcí v Azure, nahrajte je po publikování projektu. Další informace najdete v tématu Nastavení aplikace funkcí. Hodnoty v ConnectionStrings kolekci nejsou publikovány.

Kód může také číst hodnoty nastavení aplikace funkcí jako proměnné prostředí. Další informace naleznete v tématu Proměnné prostředí.

Konfigurace projektu pro místní vývoj

Modul runtime služby Functions interně používá účet úložiště. Během vývoje můžete pro tento interní účet použít platný účet úložiště nebo můžete použít emulátor Azurite.

Pro všechny typy triggerů kromě HTTP a webhooků je potřeba nastavit hodnotu Values.AzureWebJobsStorage klíče v souborulocal.settings.json :

Pro účet úložiště nastavte hodnotu na připojovací řetěz, který odpovídá vašemu účtu úložiště.
Pro emulátor nastavte hodnotu na UseDevelopmentStorage=true.

Pokud používáte emulátor, změňte toto nastavení na skutečný připojovací řetězec účtu úložiště před nasazením. Další informace naleznete v tématu Emulátor místního úložiště.

Pokud chcete nastavit připojovací řetězec účtu úložiště, postupujte následovně:

Přihlaste se k webu Azure Portal a přejděte ke svému účtu úložiště.
Vyberte Zabezpečení a síťové přístupové>klíče. V části key1 zkopírujte hodnotu připojovacího řetězce .
V projektu sady Visual Studio otevřete soubor local.settings.json . Nastavte hodnotu AzureWebJobsStorage klíče na připojovací řetězec, který jste zkopírovali.
Opakujte předchozí krok a přidejte do Values pole jedinečné klíče pro všechna další připojení, která vaše funkce vyžadují.

Přidání funkce do projektu

V funkcích knihovny tříd jazyka C# jsou vazby, které funkce používají, definovány použitím atributů v kódu. Když vytvoříte triggery funkce z poskytnutých šablon, použijí se pro vás atributy triggeru.

V Průzkumník řešení klikněte pravým tlačítkem na uzel projektu a vyberte >.
V dialogovém okně Přidat novou položku vyberte Funkci Azure a pak vyberte Přidat.
Vyberte spouštěč a nastavte požadované parametry vazby. Pokud vyberete trigger služby Storage a chcete nakonfigurovat připojení, zaškrtněte políčko pro konfiguraci připojení triggeru. Následující příklad ukazuje nastavení pro vytvoření funkce triggeru Queue Storage.
Vyberte Přidat. Pokud vyberete políčko pro konfiguraci připojení k úložišti v předchozím kroku, zobrazí se stránka Připojit k závislosti. Vyberte emulátor úložiště Azurite nebo Azure Storage a pak vyberte Další.
- Pokud vyberete emulátor úložiště Azurite, zobrazí se stránka pro připojení k emulátoru úložiště Azurite . Proveďte následující kroky:
  1. Vyberte Další.
  2. Na stránce Souhrn změn vyberte Dokončit. Visual Studio nakonfiguruje závislost a vytvoří třídu triggeru.
- Pokud vyberete Azure Storage, zobrazí se stránka Připojit ke službě Azure Storage . Proveďte následující kroky:
  1. Vyberte účet úložiště a pak vyberte Další. Visual Studio se pokusí připojit k vašemu účtu Azure a načíst koncový bod.
  2. Vyberte Další.
  3. Na stránce Souhrn změn vyberte Dokončit. Visual Studio nakonfiguruje závislost a vytvoří třídu triggeru.
Tento příklad triggeru používá nastavení aplikace pro připojení k úložišti s klíčem s názvem QueueStorage. Tento klíč uložený v souborulocal.settings.json odkazuje buď na emulátor Azurite, nebo na účet úložiště.

Prozkoumejte nově přidanou třídu. Například následující třída jazyka C# představuje základní funkci triggeru Queue Storage:

Metoda Run() je přiřazena Function. Tento atribut označuje, že metoda je vstupním bodem funkce.

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

Statická Run() metoda je opatřena FunctionName. Tento atribut označuje, že metoda je vstupním bodem funkce.

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

U každého parametru vazby zadaného do metody vstupního bodu se použije atribut specifický pro vazbu. Atribut přebírá informace o vazbě jako parametry.

V předchozím kódu má QueueTrigger první parametr použitý atribut, který označuje funkci triggeru Queue Storage. Název fronty a název nastavení připojovacího řetězce se předají jako parametry atributuQueueTrigger. Ve třídě:

Parametr názvu fronty by se měl shodovat s názvem fronty, kterou používáte v předchozím kroku k vytvoření triggeru, například myqueue-items.
Název nastavení připojovacího řetězce by se měl shodovat s názvem, který používáte v předchozím kroku k vytvoření triggeru, například QueueStorage.

Další informace najdete v tématu Trigger úložiště Azure Queue pro funkce Azure.

Pomocí předchozího postupu můžete do projektu aplikace funkcí přidat další funkce. Každá funkce v projektu může mít jinou aktivační událost, ale funkce musí mít přesně jednu aktivační událost. Další informace najdete v tématu Triggery a vazby Azure Functions.

Přidejte vazby

Stejně jako u triggerů se vstupní a výstupní vazby přidávají do vaší funkce jako atributy vazeb. Pokud chcete do funkce přidat vazby, proveďte následující kroky:

Ujistěte se, že jste projekt nakonfigurovali pro místní vývoj.
Přidejte příslušný balíček rozšíření NuGet pro každou konkrétní vazbu. Požadavky na balíček NuGet specifické pro vázání naleznete v referenčním článku pro vázání. Například požadavky na balíček pro trigger služby Azure Event Hubs najdete v tématu Trigger a vazby služby Azure Event Hubs pro Službu Azure Functions.
Pomocí následujícího příkazu v konzole Správce balíčků nainstalujte konkrétní balíček:
```
Install-Package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>
```
```
Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>
```
V tomto kódu nahraďte <BINDING_TYPE> konkrétním názvem rozšíření vazby a nahraďte <TARGET_VERSION> konkrétní verzí balíčku, například 4.0.0. Platné verze jsou uvedeny na jednotlivých stránkách balíčku na NuGet.org.
Pokud existují nastavení aplikace, která vazba potřebuje, přidejte je do Values kolekce v místním souboru nastavení.

Funkce používá tyto hodnoty při místním spuštění. Když se funkce spustí v aplikaci funkcí v Azure, použije nastavení aplikace funkcí. Visual Studio usnadňuje publikování místních nastavení do Azure.

Přidejte do podpisu metody příslušný atribut vazby. Ve následujícím kódu funkci aktivuje zpráva fronty Run. Výstupní vazba pak vytvoří novou zprávu fronty se stejným textem v jiné frontě.

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

Atribut QueueOutput definuje vazbu metody. U více výstupních vazeb místo toho tento atribut umístíte na řetězcovou vlastnost vráceného objektu. Další informace naleznete v tématu Více výstupních vazeb.

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

Atribut Queue parametru out definuje výstupní vazbu.

Připojení ke službě QueueStorage Queue Storage se získá z nastavení. Další informace najdete v referenčním článku pro konkrétní vazbu.

Úplný seznam vazeb podporovaných funkcí najdete v tématu Podporované vazby. Podrobnější příklad tohoto scénáře najdete v tématu Připojení funkcí ke službě Azure Storage pomocí sady Visual Studio.

Místní spouštění funkcí

Pomocí nástrojů Azure Functions Core Tools můžete spouštět projekty Functions na místním vývojovém počítači. Když vyberete F5 pro ladění projektu Functions, místní hostitel služby Functions (func.exe) začne naslouchat na místním portu (obvykle 7071). Všechny koncové body volatelné funkce se zapisují do výstupu a tyto koncové body můžete použít k testování funkcí. Další informace najdete v tématu Místní vývoj azure Functions pomocí nástrojů Core Tools. Při prvním spuštění funkce ze sady Visual Studio se zobrazí výzva k instalaci těchto nástrojů.

Důležité

Od verze 4.0.6517 nástrojů Core Tools musí projekty modelu v procesu odkazovat na verzi 4.5.0 nebo novější .Microsoft.NET.Sdk.Functions Pokud používáte starší verzi, příkaz func start vygeneruje chybu.

Pokud chcete funkci spustit v sadě Visual Studio v režimu ladění, proveďte následující kroky:

Vyberte F5. Pokud se zobrazí výzva, přijměte požadavek ze sady Visual Studio ke stažení a instalaci nástrojů Azure Functions Core Tools. Možná budete muset také zapnout výjimku brány firewall, aby nástroje mohly zpracovávat požadavky HTTP.
Po spuštění projektu otestujte kód stejným způsobem, jakým testujete nasazenou funkci.

Při spuštění Visual Studio v režimu ladění se body přerušení zobrazí podle očekávání.

Podrobnější scénář testování, který používá Visual Studio, najdete v části Testovací funkce dále v tomto článku.

Publikování do Azure

Když publikujete projekt Functions do Azure, Visual Studio k nasazení souborů projektu použije zip deployment. Pokud je to možné, měli byste také vybrat spustit ze souboru balíčku , aby se projekt spustil v balíčku nasazení (.zip). Další informace najdete v tématu Spuštění funkcí ze souboru balíčku v Azure.

Nenasazujte na Azure Functions pomocí Web Deploy (msdeploy).

Pomocí následujících kroků publikujte projekt do aplikace funkcí v Azure:

V Průzkumníku řešení klikněte pravým tlačítkem myši na projekt a pak vyberte Publikovat.
Na stránce Publikovat proveďte následující výběry:
- V Target vyberte Azure a pak vyberte Next (Další).
- V konkrétním cíli vyberte aplikaci Funkcí Azure a pak vyberte Další.
- V instanci služby Functions vyberte Vytvořit nový.

Vytvořte novou instanci pomocí hodnot zadaných v následující tabulce:

Nastavení	Hodnota	Popis
Jméno	Globálně jedinečný název	Název musí jednoznačně identifikovat novou aplikaci funkcí. Přijměte navrhované jméno nebo zadejte nový název. Následující znaky jsou platné: `a-z`, `0-9`a `-`.
Název předplatného	Název předplatného	Funkční aplikace byla vytvořena v předplatném Azure. Přijměte výchozí předplatné nebo vyberte jiné předplatné ze seznamu.
Skupina prostředků	Název vaší skupiny prostředků	Aplikace Function App je vytvořena ve skupině prostředků. Výběrem možnosti Nový vytvořte novou skupinu prostředků. V seznamu můžete také vybrat existující skupinu prostředků.
Typ plánu	Flex Consumption	Když projekt publikujete do aplikace funkcí, která běží v plánu Flex Consumption, můžete platit jenom za provádění aplikace funkcí. Jiné plány hostování můžou mít vyšší náklady. DŮLEŽITÉ: Při vytváření plánu Flex Consumption musíte nejprve vybrat plán služby App Service a pak znovu vybrat Flex Consumption , abyste zrušili problém s dialogem.
Operační systém	Linux	Plán Flex Consumption v současné době vyžaduje Linux.
Místo	Umístění služby aplikace	Vyberte umístění v oblasti Azure podporované plánem Flex Consumption. Když vyberete nepodporovanou oblast, tlačítko Vytvořit se zobrazí šedě.
Velikost paměti instance	2048	Velikost paměti instancí virtuálních počítačů, ve kterých se aplikace spouští, je jedinečná pro plán Flex Consumption.
Azure Storage	Účet úložiště pro obecné účely	Modul runtime služby Functions vyžaduje účet úložiště. Výběrem možnosti Nový nakonfigurujte účet úložiště pro obecné účely. Můžete také použít existující účet, který splňuje požadavky na účet úložiště.
Application Insights	Instance Application Insights	Měli byste zapnout integraci Application Insights pro vaši aplikaci funkcí. Vyberte Nový a vytvořte novou instanci, a to buď v novém, nebo v existujícím pracovním prostoru služby Log Analytics. Můžete také použít existující instanci.

Snímek obrazovky dialogového okna Vytvořit novou funkci aplikace. Jsou vyplněna pole pro název, předplatné, skupinu prostředků, plán a další nastavení.

Výběrem možnosti Vytvořit vytvoříte aplikaci funkcí a související prostředky v Azure. Stav vytváření prostředků se zobrazí v levém dolním rohu okna.
Vyberte Dokončit. Zobrazí se okno průběhu vytváření profilu publikování . Po vytvoření profilu vyberte Zavřít.
Na stránce profilu publikování vyberte Publikovat a nasaďte balíček, který obsahuje soubory projektu do nové aplikace funkcí v Azure.

Po dokončení nasazení se na stránce profilu publikování zobrazí kořenová adresa URL aplikace funkcí v Azure.
Na stránce profilu publikování přejděte do části Hostování . Vyberte výpustku (...) a pak vyberte Otevřít v Azure portálu. Nový prostředek aplikace funkcí Azure se otevře na webu Azure Portal.

Nastavení aplikace Function App

Když publikujete projekt, Visual Studio nenahraje nastavení aplikace automaticky. Pokud do souboru local.settings.json přidáte nastavení, musíte je také přidat do aplikace funkcí v Azure.

Nejjednodušší způsob, jak nahrát požadovaná nastavení do aplikace funkcí v Azure, je spravovat je v sadě Visual Studio. Na stránce profilu publikování přejděte do části Hostování . Vyberte výpustku (...) a pak vyberte Spravovat nastavení služby Azure App Service.

Po výběru se otevře dialogové okno Nastavení aplikace pro aplikaci funkcí. Toto dialogové okno můžete použít k přidání nastavení aplikace nebo úpravě existujících nastavení.

Snímek obrazovky s dialogovým oknem Nastavení aplikace zobrazující místní a vzdálené hodnoty pro různá nastavení a ovládací prvky pro přidávání a úpravy hodnot

Pro každé nastavení je místní hodnota hodnota v souboru local.settings.json a vzdálená hodnota je hodnota v aplikaci funkcí v Azure.

Pokud chcete vytvořit nastavení aplikace, vyberte Přidat nastavení.
Chcete-li zkopírovat hodnotu nastavení z pole Místní do vzdáleného pole, vyberte Vložit hodnotu z místního pole.

Čekající změny se zapíšou do místního souboru nastavení a aplikace funkcí, když vyberete OK.

Poznámka:

Ve výchozím nastavení není soubor local.settings.json zařazený do správy verzí. Pokud tedy naklonujete místní projekt Functions ze správy zdrojového kódu, projekt nemá local.settings.json soubor. Musíte ručně vytvořit soubor local.settings.json v kořenovém adresáři projektu, aby dialogové okno Nastavení aplikace fungovalo podle očekávání.

Nastavení aplikace můžete spravovat také jedním z těchto způsobů:

Použijte Azure Portal.
--publish-local-settings Použijte možnost publikování v nástrojích Azure Functions Core Tools.
Použijte Azure CLI.

Vzdálené debugování

Pokud chcete svou funkční aplikaci vzdáleně ladit, musíte publikovat ladicí konfiguraci svého projektu. V aplikaci funkcí v Azure je také potřeba zapnout vzdálené ladění.

Tato část předpokládá, že je publikována konfigurace ladění vaší funkční aplikace.

Důležité informace o vzdáleném ladění

Nedoporučuje se provádět vzdálené ladění na produkčním serveru.
Pokud chcete používat vzdálené ladění, musíte aplikaci funkcí hostovat v plánu Premium nebo App Service.
Vzdálené ladění se v současné době podporuje jenom při spuštění aplikace v jazyce C# ve Windows.
Pokud máte v sadě Visual Studio zapnutou funkci Jen můj kód, vypněte ji. Pokyny najdete v tématu Povolení nebo zakázání pouze mého kódu.
Při použití vzdáleného ladění se vyhněte dlouhým zastavením na zarážkách. Když se proces zastaví déle než několik minut, Azure ho považuje za nereagující proces a vypne ho.
Během ladění server odesílá data do sady Visual Studio, což může mít vliv na poplatky za šířku pásma. Informace o sazbách šířky pásma najdete v cenové kalkulačce.
Ve vaší aplikaci funkcí se automaticky vypne vzdálené ladění po 48 hodinách. Potom je potřeba znovu zapnout vzdálené ladění.

Připojte ladicí program

Při ladění aplikace izolovaného pracovního procesu je aktuálně potřeba připojit vzdálený ladicí program k samostatnému procesu .NET. Vyžaduje se také několik dalších kroků konfigurace.

Pokud chcete připojit vzdálený ladicí program k aplikaci funkcí spuštěné v procesu odděleně od hostitele Functions, proveďte následující kroky:

Na stránce profilu publikování přejděte do části Hostování . Vyberte výpustku (...) a pak vyberte Připojit ladicí program.

Visual Studio se připojí k aplikaci funkcí a zapne vzdálené ladění, pokud ještě není zapnuté.

Poznámka:

Vzhledem k tomu, že se vzdálený ladicí program nemůže připojit k hostitelskému procesu, může se zobrazit chybová zpráva. V každém případě místní ladicí program nemůže získat přístup k vašim bodům přerušení ani umožnit kontrolu proměnných nebo krokovat kódem.
V nabídce Ladění sady Visual Studio vyberte Připojit k procesu.
V dialogovém okně Připojit k procesu proveďte následující kroky:
1. Vedle typu připojení vyberte Microsoft Azure App Services.
2. Vedle cíle připojení vyberte Najít.
V dialogovém okně Připojit k procesu Azure vyhledejte a vyberte aplikaci funkcí a pak vyberte OK.
Pokud se zobrazí výzva, povolte sadě Visual Studio přístup přes místní bránu firewall.
Zpět v dialogovém okně Připojit k procesu vyberte Zobrazit procesy pro všechny uživatele. Vyberte dotnet.exea pak vyberte Připojit.

Po dokončení operace budete připojeni k kódu knihovny tříd jazyka C#, který běží v izolovaném pracovním procesu. V tomto okamžiku můžete svou funkční aplikaci ladit obvyklým způsobem.

Chcete-li připojit vzdálený ladicí program k aplikaci funkcí, která běží v procesním prostoru hosta Functions, proveďte následující kroky.

Na stránce profilu publikování přejděte do části Hostování . Vyberte výpustku (...) a pak vyberte Připojit ladicí program.

Visual Studio se připojí k aplikaci funkcí a zapne vzdálené ladění, pokud ještě není zapnuté. Také lokalizuje a připojuje debugger k hostitelskému procesu aplikace. V tomto okamžiku můžete svou funkční aplikaci ladit obvyklým způsobem.

Po dokončení ladění byste měli vzdálené ladění vypnout.

Vypnutí vzdáleného ladění

Po dokončení vzdáleného ladění kódu byste měli na webu Azure Portal vypnout vzdálené ladění. Vzdálené ladění se po 48 hodinách automaticky vypne, pokud zapomenete.

Na stránce profilu publikování přejděte do části Hostování . Vyberte výpustku (...) a pak vyberte Otevřít v Azure portálu. Portál Azure otevře aplikaci funkcí, na kterou je váš projekt nasazen.
V aplikaci funkcí vyberte Konfigurace nastavení> a pak přejděte na kartu Obecné nastavení. Vedle možnosti Vzdálené ladění vyberte Vypnuto. Vyberte Uložit a pak vyberte Pokračovat.

Po restartování aplikace funkcí se už nemůžete vzdáleně připojit ke vzdáleným procesům. Stejnou kartu můžete použít na webu Azure Portal k zapnutí vzdáleného ladění mimo Visual Studio.

Monitorování funkcí

Doporučeným způsobem monitorování funkcí je integrace aplikace funkcí s Application Insights. Tuto integraci byste měli zapnout při vytváření aplikace funkcí během publikování sady Visual Studio.

Pokud integrace není z nějakého důvodu nastavená při publikování, měli byste i přesto zapnout integraci Application Insights pro vaši funkční aplikaci v Azure.

Další informace o používání Application Insights pro monitorování najdete v tématu Monitorování spuštění ve službě Azure Functions.

Testovací funkce

Tato část popisuje, jak vytvořit projekt modelu v procesu jazyka C#, který můžete testovat pomocí xUnit, což je opensourcový nástroj pro testování jednotek pro .NET.

Krok 1: Nastavení

Podle těchto kroků nakonfigurujte prostředí, včetně projektu a funkcí aplikace, které jsou potřeba pro podporu testů:

V sadě Visual Studio vytvořte projekt Azure Functions s názvem Functions.
Ze šablony vytvořte funkci HTTP:
1. V Průzkumníku řešení klikněte pravým tlačítkem na projekt Functions a pak vyberte Přidat>novou funkci Azure Functions.
2. V dialogovém okně Přidat novou položku vyberte Funkci Azure a pak vyberte Přidat.
3. Vyberte trigger HTTP a pak vyberte Přidat.
4. Přejmenujte novou třídu MyHttpTrigger.
Ze šablony vytvořte funkci časovače:
1. V Průzkumníku řešení klikněte pravým tlačítkem na projekt Functions a pak vyberte Přidat>novou funkci Azure Functions.
2. V dialogovém okně Přidat novou položku vyberte Funkci Azure a pak vyberte Přidat.
3. Vyberte spouštěč časovače a pak vyberte Přidat.
4. Přejmenujte novou třídu MyTimerTrigger.
V řešení vytvořte testovací aplikaci xUnit :
1. V Průzkumníku řešení klikněte pravým tlačítkem myši na řešení, které obsahuje váš projekt Functions , a pak vyberte Přidat>nový projekt.
2. Vyberte šablonu projektu testování xUnit a pak vyberte Další.
3. Pojmenujte projekt Functions.Tests.
Odeberte výchozí testovací soubory z projektu Functions.Tests .
Použijte NuGet k přidání odkazu z testovací aplikace do Microsoft.AspNetCore.Mvc. Můžete použít konzolu Správce balíčků nebo můžete provést následující kroky:
1. V Průzkumníku řešení klikněte pravým tlačítkem na projekt Functions.Tests a pak vyberte Spravovat balíčky NuGet.
2. Vyhledejte a nainstalujte Microsoft.AspNetCore.Mvc.
V aplikaci Functions.Testspřidejte odkaz na aplikaci Functions :
1. V Průzkumníku řešení klikněte pravým tlačítkem myši na projekt Functions.Tests a pak vyberte Přidat>odkaz projektu.
2. Vyberte projekt Functions a pak vyberte OK.

Krok 2: Vytvoření testovacích tříd

V této části vytvoříte třídy, které použijete ke spuštění automatizovaných testů.

Každá funkce vyžaduje implementaci ILogger pro zpracování protokolování zpráv. V některých testech nejsou zaprotokolovány žádné zprávy nebo nezáleží na tom, jak se protokolování implementuje. Jiné testy musí vyhodnotit protokolované zprávy, aby bylo možné určit, jestli má test projít.

Ve svém projektu Functions.Tests vytvořte třídu s názvem NullScope a přidejte následující kód. Tato třída poskytuje simulovaný rozsah. V pozdějším kroku vytvoříte implementaci ILogger , která tento obor používá.

using System;

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

        private NullScope() { }

        public void Dispose() { }
    }
}

Ve svém projektu Functions.Tests vytvořte třídu s názvem ListLogger a přidejte následující kód. Tato třída udržuje interní seznam zpráv, které se mají vyhodnotit během testování. K implementaci požadovaného ILogger rozhraní třída používá obor napodobení z NullScope třídy. Testovací případy předávají napodobení oboru do třídy ListLogger.
```
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);
        }
    }
}
```
Třída ListLogger implementuje následující členy, jak je kontraktováno ILogger rozhraním:
- BeginScope: Obory přidávají do protokolování kontext. V tomto případě test odkazuje na statickou instanci třídy NullScope , aby test mohl fungovat.
- IsEnabled: Je k dispozici výchozí hodnota false .
- Log: Tato metoda používá zadanou formatter funkci k formátování zprávy. Metoda pak přidá výsledný text do Logs kolekce.
Kolekce Logs je instance List<string> a je inicializována v konstruktoru.
V projektu Functions.Tests vytvořte soubor kódu s názvem LoggerTypes.cs a přidejte následující kód:
```
namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}
```
Tento výčet určuje typ protokolovacího nástroje, který testy používají.

Vytvořte třídu v projektu Functions.Tests s názvem TestFactory a přidejte následující kód:

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

Třída TestFactory implementuje následující členy:

Data: Tato vlastnost vrátí IEnumerable kolekci ukázkových dat. Páry klíč-hodnota představují hodnoty, které jsou předány do řetězce dotazu.
CreateDictionary: Tato metoda přijímá dvojici klíč-hodnota jako argument. Vrátí novou instanci Dictionary, která je použita k vytvoření instance QueryCollection představující hodnoty řetězce dotazu.
CreateHttpRequest: Tato metoda vytvoří požadavek HTTP, který se inicializuje s danými parametry řetězce dotazu.
CreateLogger: Tato metoda vrátí implementaci ILogger , která se používá k testování. Implementace ILogger závisí na zadaném typu protokolovacího nástroje. Pokud je zadán typ seznamu, ListLogger instance sleduje protokolované zprávy, které jsou k dispozici pro vyhodnocení v testech.

Vytvořte třídu v projektu Functions.Tests s názvem FunctionsTests a přidejte následující kód:

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

Tato třída implementuje následující členy:

Http_trigger_should_return_known_string: Tento test používá hodnotu name=Bernardo řetězce dotazu k vytvoření požadavku na funkci HTTP. Tento test zkontroluje, jestli se vrátí očekávaná odpověď.
Http_trigger_should_return_string_from_member_data: Tento test používá atributy xUnit k poskytování ukázkových dat funkci HTTP.
Timer_should_log_message: Tento test vytvoří instanci ListLogger a předá ji funkci časovače. Po spuštění funkce se zkontroluje protokol, aby se ujistil, že je k dispozici očekávaná zpráva.

Pokud chcete získat přístup k nastavení aplikace v testech, můžete do funkce vložitIConfiguration implementaci s napodobenými hodnotami proměnných prostředí.

Krok 3: Spuštění testů

Pokud chcete testy spustit v sadě Visual Studio, vyberte Zobrazit>Průzkumníka testů. V Průzkumníku testů vyberte Spustit>všechny testy v zobrazení.

Snímek obrazovky z Visual Studio. Průzkumník testů ve Visual Studio ukazuje, že pět testů bylo úspěšně dokončeno. V Průzkumníku řešení jsou viditelné projekty Functions a Functions.Test.

Krok 4: Ladění testů

Pokud chcete testy ladit, nastavte pro test zarážku. V Průzkumníku testů vyberte Spustit>Ladit poslední spuštění.

místní vývoj Azure Functions pomocí nástrojů Core Tools

Průvodce modelem v procesu v jazyce C#

Průvodce izolovaným pracovním modelem jazyka C#

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-09-23