Udostępnij za pośrednictwem

Opracowywanie funkcji usługi Azure Functions przy użyciu programu Visual Studio

  • Artykuł

Program Visual Studio umożliwia tworzenie, testowanie i wdrażanie funkcji biblioteki klas języka C# na platformie Azure. Jeśli to środowisko jest twoje pierwsze w usłudze Azure Functions, zobacz Wprowadzenie do usługi Azure Functions.

Aby od razu rozpocząć pracę, rozważ ukończenie przewodnika Szybki start usługi Functions dla programu Visual Studio.

Ten artykuł zawiera szczegółowe informacje na temat sposobu używania programu Visual Studio do tworzenia funkcji biblioteki klas języka C# i publikowania ich na platformie Azure. Istnieją dwa modele tworzenia funkcji biblioteki klas języka C#: model izolowanego procesu roboczego i model in-process.

Czytasz izolowana wersja modelu procesu roboczego w tym artykule. W górnej części artykułu możesz wybrać preferowany model.

Czytasz wersję modelu procesu w tym artykule. W górnej części artykułu możesz wybrać preferowany model.

Jeśli nie określono inaczej, pokazano procedury i przykłady dla programu Visual Studio 2022. Aby uzyskać więcej informacji na temat wersji programu Visual Studio 2022, zobacz informacje o wersji lub informacje o wersji zapoznawczej.

Wymagania wstępne

  • Program Visual Studio 2022, w tym obciążenie programistyczne platformy Azure.

  • Inne potrzebne zasoby, takie jak konto usługi Azure Storage, są tworzone w ramach subskrypcji podczas procesu publikowania.

  • Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Tworzenie projektu usługi Azure Functions

Szablon projektu usługi Azure Functions w programie Visual Studio tworzy projekt biblioteki klas języka C#, który można opublikować w aplikacji funkcji na platformie Azure. Za pomocą aplikacji funkcji można grupować funkcje jako jednostkę logiczną, aby ułatwić zarządzanie, wdrażanie, skalowanie i udostępnianie zasobów.

  1. Z menu programu Visual Studio wybierz pozycję Plik>nowy>projekt.

  2. W obszarze Tworzenie nowego projektu wprowadź funkcje w polu wyszukiwania, wybierz szablon usługi Azure Functions , a następnie wybierz pozycję Dalej.

  3. W obszarze Konfigurowanie nowego projektu wprowadź nazwę projektu, a następnie wybierz pozycję Utwórz. Nazwa aplikacji funkcji musi być prawidłową nazwą przestrzeni nazw C#, dlatego nie należy używać znaków podkreślenia, łączników ani znaków innych niż alfanumeryczne.

  4. W przypadku ustawień tworzenia nowej aplikacji usługi Azure Functions użyj wartości w poniższej tabeli:

    Ustawienie Wartość Opis
    Wersja platformy .NET Izolowana platforma .NET 6 Ta wartość tworzy projekt funkcji uruchamiany w izolowanym procesie roboczym. Proces izolowany proces roboczy obsługuje inną niż LTS wersję platformy .NET, a także .NET Framework. Aby uzyskać więcej informacji, zobacz Omówienie wersji środowiska uruchomieniowego usługi Azure Functions.
    Szablon funkcji Wyzwalacz HTTP Ta wartość tworzy funkcję wyzwalaną przez żądanie HTTP.
    Konto magazynu (AzureWebJobsStorage) Emulator magazynu Ponieważ aplikacja funkcji na platformie Azure wymaga konta magazynu, jest przypisywana lub tworzona podczas publikowania projektu na platformie Azure. Wyzwalacz HTTP nie używa konta usługi Azure Storage parametry połączenia; wszystkie inne typy wyzwalaczy wymagają prawidłowego konta usługi Azure Storage parametry połączenia.
    Poziom autoryzacji Anonimowy Utworzona funkcja może zostać wyzwolona przez dowolnego klienta bez podawania klucza. To ustawienie autoryzacji ułatwia testowanie nowej funkcji. Aby uzyskać więcej informacji, zobacz Poziom autoryzacji.

    Zrzut ekranu przedstawiający ustawienia projektu usługi Azure Functions

    Ustawienie Wartość Opis
    Wersja platformy .NET .NET 6 Ta wartość tworzy projekt funkcji, który jest uruchamiany w procesie z wersją 4.x środowiska uruchomieniowego usługi Azure Functions. Aby uzyskać więcej informacji, zobacz Omówienie wersji środowiska uruchomieniowego usługi Azure Functions.
    Szablon funkcji Wyzwalacz HTTP Ta wartość tworzy funkcję wyzwalaną przez żądanie HTTP.
    Konto magazynu (AzureWebJobsStorage) Emulator magazynu Ponieważ aplikacja funkcji na platformie Azure wymaga konta magazynu, jest przypisywana lub tworzona podczas publikowania projektu na platformie Azure. Wyzwalacz HTTP nie używa konta usługi Azure Storage parametry połączenia; wszystkie inne typy wyzwalaczy wymagają prawidłowego konta usługi Azure Storage parametry połączenia.
    Poziom autoryzacji Anonimowy Utworzona funkcja może zostać wyzwolona przez dowolnego klienta bez podawania klucza. To ustawienie autoryzacji ułatwia testowanie nowej funkcji. Aby uzyskać więcej informacji, zobacz Poziom autoryzacji.

    Zrzut ekranu przedstawiający ustawienia projektu usługi Azure Functions

    Upewnij się, że ustawiono poziom autoryzacji na Anonimowy. Jeśli wybierzesz domyślny poziom funkcji, musisz przedstawić klucz funkcji w żądaniach dostępu do punktu końcowego funkcji.

  5. Wybierz pozycję Utwórz , aby utworzyć projekt funkcji i funkcję wyzwalacza HTTP.

Po utworzeniu projektu usługi Azure Functions szablon projektu tworzy projekt w języku C#, instaluje Microsoft.Azure.Functions.Worker pakiety NuGet i Microsoft.Azure.Functions.Worker.Sdk ustawia strukturę docelową.

Po utworzeniu projektu usługi Azure Functions szablon projektu tworzy projekt w języku C#, instaluje Microsoft.NET.Sdk.Functions pakiet NuGet i ustawia platformę docelową.

Nowy projekt ma następujące pliki:

  • host.json: umożliwia skonfigurowanie hosta usługi Functions. Te ustawienia mają zastosowanie zarówno w przypadku uruchamiania lokalnego, jak i na platformie Azure. Aby uzyskać więcej informacji, zobacz host.json dokumentacji.

  • local.settings.json: zachowuje ustawienia używane podczas lokalnego uruchamiania funkcji. Te ustawienia nie są używane podczas uruchamiania na platformie Azure. Aby uzyskać więcej informacji, zobacz Plik ustawień lokalnych.

    Ważne

    Ponieważ plik local.settings.json może zawierać wpisy tajne, należy wykluczyć go z kontroli źródła projektu. Upewnij się, że ustawienie Kopiuj do katalogu wyjściowego dla tego pliku ma wartość Kopiuj, jeśli jest nowsza.

Aby uzyskać więcej informacji, zobacz Project structure (Struktura projektu) w przewodniku izolowanego procesu roboczego.

Aby uzyskać więcej informacji, zobacz Projekt biblioteki klas usługi Functions.

Praca z ustawieniami aplikacji lokalnie

W przypadku uruchamiania w aplikacji funkcji na platformie Azure ustawienia wymagane przez funkcje są bezpiecznie przechowywane w ustawieniach aplikacji. Podczas programowania lokalnego te ustawienia są zamiast tego dodawane do Values kolekcji w pliku local.settings.json. Plik local.settings.json przechowuje również ustawienia używane przez lokalne narzędzia programistyczne.

Elementy w Values kolekcji w pliku local.settings.json projektu mają na celu dublowanie elementów w ustawieniach aplikacji funkcji na platformie Azure.

Program Visual Studio nie przekazuje automatycznie ustawień w local.settings.json podczas publikowania projektu. Aby upewnić się, że te ustawienia również istnieją w aplikacji funkcji na platformie Azure, przekaż je po opublikowaniu projektu. Aby uzyskać więcej informacji, zobacz Ustawienia aplikacji funkcji. Wartości w ConnectionStrings kolekcji nigdy nie są publikowane.

Kod może również odczytywać wartości ustawień aplikacji funkcji jako zmienne środowiskowe. Aby uzyskać więcej informacji, zobacz Zmienne środowiskowe.

Konfigurowanie projektu na potrzeby programowania lokalnego

Środowisko uruchomieniowe usługi Functions używa konta usługi Azure Storage wewnętrznie. Dla wszystkich typów wyzwalaczy innych niż HTTP i webhook ustaw Values.AzureWebJobsStorage klucz na prawidłowe konto usługi Azure Storage parametry połączenia. Aplikacja funkcji może również użyć emulatora Azurite dla AzureWebJobsStorage ustawienia połączenia wymaganego przez projekt. Aby użyć emulatora, ustaw wartość na AzureWebJobsStorage UseDevelopmentStorage=true. Zmień to ustawienie na rzeczywiste konto magazynu parametry połączenia przed wdrożeniem. Aby uzyskać więcej informacji, zobacz Emulator magazynu lokalnego.

Aby ustawić parametry połączenia konta magazynu:

  1. W witrynie Azure Portal przejdź do swojego konta magazynu.

  2. Na karcie Klucze dostępu pod pozycją Zabezpieczenia i sieć skopiuj parametry połączenia klucza key1.

  3. W projekcie otwórz plik local.settings.json i ustaw wartość AzureWebJobsStorage klucza na skopiowaną parametry połączenia.

  4. Powtórz poprzedni krok, aby dodać unikatowe klucze do Values tablicy dla innych połączeń wymaganych przez funkcje.

Dodawanie funkcji do projektu

W funkcjach biblioteki klas języka C# powiązania używane przez funkcję są definiowane przez zastosowanie atrybutów w kodzie. Po utworzeniu wyzwalaczy funkcji z podanych szablonów zostaną zastosowane atrybuty wyzwalacza.

  1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł projektu i wybierz polecenie Dodaj>nową funkcję platformy Azure.

  2. Wprowadź nazwę klasy, a następnie wybierz pozycję Dodaj.

  3. Wybierz wyzwalacz, ustaw wymagane właściwości powiązania, a następnie wybierz pozycję Dodaj. W poniższym przykładzie przedstawiono ustawienia tworzenia funkcji wyzwalacza magazynu kolejek.

    Tworzenie funkcji wyzwalacza usługi Queue Storage

    W przypadku wyzwalacza usługi Azure Storage zaznacz pole Konfigurowanie połączenia i zostanie wyświetlony monit o wybranie między używaniem emulatora magazynu Azurite lub odwoływaniem się do aprowizowanego konta usługi Azure Storage. Wybierz pozycję Dalej, a jeśli wybierzesz konto magazynu, program Visual Studio spróbuje nawiązać połączenie z kontem platformy Azure i uzyskać parametry połączenia. Wybierz pozycję Zapisz parametry połączenia wartość w pliku wpisów tajnych użytkownika lokalnego, a następnie pozycję Zakończ, aby utworzyć klasę wyzwalacza.

    Ten przykład wyzwalacza używa ustawienia aplikacji dla połączenia magazynu z kluczem o nazwie QueueStorage. Ten klucz przechowywany w pliku local.settings.json odwołuje się do emulatora usługi Azurite lub konta usługi Azure Storage.

  4. Sprawdź nowo dodaną klasę. Na przykład następująca klasa C# reprezentuje podstawową funkcję wyzwalacza usługi Queue Storage:

    Zobaczysz metodę statyczną Run() przypisaną za pomocą Functionpolecenia . Ten atrybut wskazuje, że metoda jest punktem wejścia dla funkcji.

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

    Zobaczysz metodę statyczną Run() przypisaną za pomocą FunctionNamepolecenia . Ten atrybut wskazuje, że metoda jest punktem wejścia dla funkcji.

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

Atrybut specyficzny dla powiązania jest stosowany do każdego parametru powiązania dostarczonego do metody punktu wejścia. Atrybut przyjmuje informacje o powiązaniu jako parametry. W poprzednim przykładzie pierwszy parametr ma QueueTrigger zastosowany atrybut wskazujący funkcję wyzwalacza usługi Queue Storage. Nazwa kolejki i nazwa ustawienia parametry połączenia są przekazywane jako parametry do atrybutuQueueTrigger. Aby uzyskać więcej informacji, zobacz Powiązania usługi Azure Queue Storage dla usługi Azure Functions.

Użyj powyższej procedury, aby dodać więcej funkcji do projektu aplikacji funkcji. Każda funkcja w projekcie może mieć inny wyzwalacz, ale funkcja musi mieć dokładnie jeden wyzwalacz. Aby uzyskać więcej informacji, zobacz Pojęcia powiązań i wyzwalaczy usługi Azure Functions.

Dodawanie powiązań

Podobnie jak w przypadku wyzwalaczy, powiązania wejściowe i wyjściowe są dodawane do funkcji jako atrybuty powiązania. Dodaj powiązania do funkcji w następujący sposób:

  1. Upewnij się, że projekt został skonfigurowany na potrzeby programowania lokalnego.

  2. Dodaj odpowiedni pakiet rozszerzenia NuGet dla określonego powiązania, wyszukując wymagania dotyczące pakietu NuGet specyficzne dla powiązania w artykule referencyjnym dotyczącym powiązania. Na przykład znajdź wymagania dotyczące pakietu dla wyzwalacza usługi Event Hubs w artykule Dokumentacja powiązania usługi Event Hubs.

  3. Użyj następującego polecenia w konsoli Menedżer pakietów, aby zainstalować określony pakiet:

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

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

    W tym przykładzie zastąp <BINDING_TYPE> ciąg nazwą specyficzną dla rozszerzenia powiązania i <TARGET_VERSION> określoną wersją pakietu, taką jak 4.0.0. Prawidłowe wersje są wyświetlane na poszczególnych stronach pakietów w NuGet.org.

  4. Jeśli istnieją ustawienia aplikacji wymagane przez powiązanie, dodaj je do Values kolekcji w pliku ustawień lokalnych.

    Funkcja używa tych wartości, gdy jest uruchamiana lokalnie. Gdy funkcja jest uruchamiana w aplikacji funkcji na platformie Azure, używa ustawień aplikacji funkcji. Program Visual Studio ułatwia publikowanie ustawień lokalnych na platformie Azure.

  5. Dodaj odpowiedni atrybut powiązania do podpisu metody. W poniższym przykładzie komunikat kolejki wyzwala funkcję, a powiązanie wyjściowe tworzy nowy komunikat kolejki z tym samym tekstem w innej kolejce.

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

    Atrybut QueueOutput definiuje powiązanie metody . W przypadku wielu powiązań wyjściowych zamiast tego należy umieścić ten atrybut we właściwości string zwróconego obiektu. Aby uzyskać więcej informacji, zobacz Wiele powiązań wyjściowych.

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

    Atrybut Queue w parametrze out definiuje powiązanie wyjściowe.

    Połączenie z usługą QueueStorage Queue Storage jest uzyskiwane z ustawienia . Aby uzyskać więcej informacji, zobacz artykuł referencyjny dotyczący określonego powiązania.

Aby uzyskać pełną listę powiązań obsługiwanych przez funkcje, zobacz Obsługiwane powiązania.

Uruchamianie funkcji lokalnie

Podstawowe narzędzia usługi Azure Functions umożliwiają uruchamianie projektu usługi Azure Functions na lokalnym komputerze deweloperskim. Po naciśnięciu F5 w celu debugowania projektu usługi Functions lokalny host usługi Functions (func.exe) zaczyna nasłuchiwać na porcie lokalnym (zwykle 7071). Wszystkie wywoływane punkty końcowe funkcji są zapisywane w danych wyjściowych i można użyć tych punktów końcowych do testowania funkcji. Aby uzyskać więcej informacji, zobacz Praca z narzędziami Azure Functions Core Tools. Zostanie wyświetlony monit o zainstalowanie tych narzędzi przy pierwszym uruchomieniu funkcji z poziomu programu Visual Studio.

Ważne

Począwszy od wersji 4.0.6517 narzędzi Core Tools, projekty modelu przetwarzania muszą odwoływać się do wersji 4.5.0 lub nowszej .Microsoft.NET.Sdk.Functions Jeśli jest używana wcześniejsza wersja, func start polecenie spowoduje błąd.

Aby uruchomić funkcję w programie Visual Studio w trybie debugowania:

  1. Naciśnij klawisz F5. Po wyświetleniu monitu zaakceptuj żądanie programu Visual Studio dotyczące pobrania i zainstalowania zestawu narzędzi Azure Functions Core (CLI). Może być również konieczne włączenie wyjątku zapory, aby narzędzia mogły obsługiwać żądania HTTP.

  2. Po uruchomieniu projektu przetestuj kod w taki sposób, jak w przypadku testowania wdrożonej funkcji.

    Po uruchomieniu programu Visual Studio w trybie debugowania punkty przerwania są osiągane zgodnie z oczekiwaniami.

Aby uzyskać bardziej szczegółowy scenariusz testowania przy użyciu programu Visual Studio, zobacz Testowanie funkcji.

Publikowanie na platformie Azure

Podczas publikowania projektu funkcji na platformie Azure program Visual Studio używa wdrożenia zip do wdrażania plików projektu. Jeśli to możliwe, należy również wybrać pozycję Uruchom z pakietu, aby projekt był uruchamiany w pakiecie wdrożeniowym (.zip). Aby uzyskać więcej informacji, zobacz Uruchamianie funkcji z pliku pakietu na platformie Azure.

Nie wdrażaj w usłudze Azure Functions przy użyciu narzędzia Web Deploy (msdeploy).

Wykonaj poniższe kroki, aby opublikować projekt w aplikacji funkcji na platformie Azure.

  1. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Opublikuj. W obszarze Cel wybierz pozycję Azure, a następnie wybierz pozycję Dalej.

    Zrzut ekranu przedstawiający okienko publikowania.

  2. W obszarze Określony element docelowy wybierz pozycję Aplikacja funkcji platformy Azure (Windows). Zostanie utworzona aplikacja funkcji działająca w systemie Windows. Wybierz Dalej.

    Zrzut ekranu przedstawiający okienko publikowania, które ma określony element docelowy.

  3. W wystąpieniu usługi Functions wybierz pozycję Utwórz nową funkcję platformy Azure.

    Zrzut ekranu przedstawiający tworzenie nowego wystąpienia aplikacji funkcji.

  4. Utwórz nowe wystąpienie przy użyciu wartości określonych w poniższej tabeli:

    Ustawienie Wartość Opis
    Nazwa/nazwisko Nazwa unikatowa w skali globalnej Unikatowa nazwa identyfikująca nową aplikację funkcji. Zaakceptuj tę nazwę lub wprowadź nową nazwę. Prawidłowe znaki to: a-z, 0-9i -.
    Subskrypcja Twoja subskrypcja Subskrypcja platformy Azure, która ma być używana. Zaakceptuj tę subskrypcję lub wybierz nową z listy rozwijanej.
    Grupa zasobów: Nazwa grupy zasobów Grupa zasobów, w której chcesz utworzyć aplikację funkcji. Wybierz pozycję Nowy , aby utworzyć nową grupę zasobów. Możesz również użyć istniejącej grupy zasobów z listy rozwijanej.
    Typ planu Zużycie Podczas publikowania projektu w aplikacji funkcji uruchamianej w planie Zużycie płacisz tylko za wykonania aplikacji funkcji. Inne plany hostingu generują wyższe koszty.
    Lokalizacja Lokalizacja usługi App Service Wybierz lokalizację w regionie świadczenia usługi Azure w pobliżu Ciebie lub innych usług, do których uzyskujesz dostęp do funkcji.
    Azure Storage Konto magazynu ogólnego przeznaczenia Środowisko uruchomieniowe usługi Functions wymaga konta magazynu platformy Azure. Wybierz pozycję Nowy , aby skonfigurować konto magazynu ogólnego przeznaczenia. Możesz również użyć istniejącego konta spełniającego wymagania dotyczące konta magazynu.
    Application Insights Wystąpienie usługi Application Insights Należy włączyć integrację aplikacja systemu Azure Insights dla aplikacji funkcji. Wybierz pozycję Nowy , aby utworzyć nowe wystąpienie w nowym lub istniejącym obszarze roboczym usługi Log Analytics. Możesz również użyć istniejącego wystąpienia.

    Zrzut ekranu przedstawiający okno dialogowe Tworzenie usługi App Service.

  5. Wybierz pozycję Utwórz , aby utworzyć aplikację funkcji i powiązane z nią zasoby na platformie Azure. Stan tworzenia zasobów jest wyświetlany w lewym dolnym rogu okna.

  6. W wystąpieniu usługi Functions upewnij się, że pole wyboru Uruchom z pliku pakietu jest zaznaczone. Aplikacja funkcji jest wdrażana przy użyciu funkcji Zip Deploy z włączonym trybem Run-From-Package . Zip Deploy to zalecana metoda wdrażania dla projektu funkcji w celu uzyskania lepszej wydajności.

    Zrzut ekranu przedstawiający okienko Kończenie tworzenia profilu.

  7. Wybierz pozycję Zakończ, a następnie w okienku Publikowanie wybierz pozycję Publikuj , aby wdrożyć pakiet zawierający pliki projektu w nowej aplikacji funkcji na platformie Azure.

    Po zakończeniu wdrażania główny adres URL aplikacji funkcji na platformie Azure jest wyświetlany na karcie Publikowanie .

  8. Na karcie Publikowanie w sekcji Hosting wybierz pozycję Otwórz w witrynie Azure Portal. Nowy zasób aplikacji funkcji platformy Azure zostanie otwarty w witrynie Azure Portal.

    Zrzut ekranu przedstawiający komunikat o powodzeniu publikowania.

Ustawienia aplikacji funkcji

Program Visual Studio nie przekazuje tych ustawień automatycznie podczas publikowania projektu. Wszystkie ustawienia dodawane w local.settings.json należy również dodać do aplikacji funkcji na platformie Azure.

Najprostszym sposobem przekazania wymaganych ustawień do aplikacji funkcji na platformie Azure jest rozwinięcie trzech kropek obok sekcji Hosting i wybranie linku Zarządzaj ustawieniami usługi aplikacja systemu Azure, który zostanie wyświetlony po pomyślnym opublikowaniu projektu.

Ustawienia w oknie Publikowanie

Wybranie tego linku spowoduje wyświetlenie okna dialogowego Ustawienia aplikacji dla aplikacji funkcji, w którym można dodać nowe ustawienia aplikacji lub zmodyfikować istniejące.

Ustawienia aplikacji

Lokalnie wyświetla wartość ustawienia w pliku local.settings.json, a Remote wyświetla bieżącą wartość ustawienia w aplikacji funkcji na platformie Azure. Wybierz pozycję Dodaj ustawienie, aby utworzyć nowe ustawienie aplikacji. Użyj linku Wstaw wartość z lokalizacji lokalnej , aby skopiować wartość ustawienia do pola Zdalne . Oczekujące zmiany są zapisywane w pliku ustawień lokalnych i aplikacji funkcji po wybraniu przycisku OK.

Uwaga

Domyślnie plik local.settings.json nie jest ewidencjona w kontroli źródła. Oznacza to, że w przypadku klonowania lokalnego projektu usługi Functions z kontroli źródła projekt nie ma pliku local.settings.json. W takim przypadku należy ręcznie utworzyć plik local.settings.json w katalogu głównym projektu, aby okno dialogowe Ustawienia aplikacji działało zgodnie z oczekiwaniami.

Ustawienia aplikacji można również zarządzać na jeden z następujących sposobów:

Debugowanie zdalne

Aby zdalnie debugować aplikację funkcji, musisz opublikować konfigurację debugowania projektu. Należy również włączyć zdalne debugowanie w aplikacji funkcji na platformie Azure.

W tej sekcji założono, że aplikacja funkcji została już opublikowana przy użyciu konfiguracji wydania.

Zagadnienia dotyczące zdalnego debugowania

  • Debugowanie zdalne nie jest zalecane w usłudze produkcyjnej.
  • Jeśli masz włączone debugowanie Tylko mój kod, wyłącz go.
  • Unikaj długich zatrzymań w punktach przerwania podczas zdalnego debugowania. Platforma Azure traktuje proces zatrzymany przez dłużej niż kilka minut jako proces nieodpowiadujący i wyłącza go.
  • Podczas debugowania serwer wysyła dane do programu Visual Studio, co może mieć wpływ na opłaty za przepustowość. Aby uzyskać informacje o szybkościach przepustowości, zobacz Cennik platformy Azure.
  • Zdalne debugowanie jest automatycznie wyłączone w aplikacji funkcji po 48 godzinach. Po 48 godzinach należy ponownie włączyć zdalne debugowanie.

Dołączanie debugera

Sposób dołączania debugera zależy od trybu wykonywania. Podczas debugowania izolowanej aplikacji procesu roboczego należy obecnie dołączyć debuger zdalny do oddzielnego procesu platformy .NET, a kilka innych kroków konfiguracji jest wymaganych.

Po zakończeniu należy wyłączyć debugowanie zdalne.

Aby dołączyć zdalny debuger do aplikacji funkcji uruchomionej w procesie niezależnie od hosta usługi Functions:

  1. Na karcie Publikowanie wybierz wielokropek (...) w sekcji Hosting, a następnie wybierz pozycję Pobierz profil publikowania. Ta akcja spowoduje pobranie kopii profilu publikowania i otwarcie lokalizacji pobierania. Potrzebny jest ten plik, który zawiera poświadczenia używane do dołączania do izolowanego procesu roboczego uruchomionego na platformie Azure.

    Uwaga

    Plik publishsettings zawiera poświadczenia (niezakodowane), które są używane do administrowania aplikacją funkcji. Najlepszym rozwiązaniem w zakresie zabezpieczeń dla tego pliku jest tymczasowe przechowywanie go poza katalogami źródłowymi (na przykład w folderze Libraries\Documents), a następnie usunięcie go po tym, jak nie jest już potrzebne. Złośliwy użytkownik, który uzyskuje dostęp do pliku .publishsettings, może edytować, tworzyć i usuwać aplikację funkcji.

  2. Ponownie na karcie Publikowanie wybierz wielokropek (...) w sekcji Hosting, a następnie wybierz pozycję Dołącz debuger.

    Zrzut ekranu przedstawiający dołączanie debugera z programu Visual Studio.

    Program Visual Studio łączy się z aplikacją funkcji i włącza zdalne debugowanie, jeśli nie jest jeszcze włączone.

    Uwaga

    Ponieważ zdalny debuger nie może nawiązać połączenia z procesem hosta, może zostać wyświetlony błąd. W każdym razie domyślne debugowanie nie spowoduje włamania się do kodu.

  3. Po powrocie do programu Visual Studio skopiuj adres URL witryny w obszarze Hosting na stronie Publikowanie .

  4. W menu Debugowanie wybierz pozycję Dołącz do procesu, a następnie w oknie Dołączanie do procesu wklej adres URL w elemecie Element docelowy połączenia, usuń https:// i dołącz port :4024.

    Sprawdź, czy element docelowy wygląda jak <FUNCTION_APP>.azurewebsites.net:4024 i naciśnij Enter.

    Okno dialogowe dołączania do procesu w programie Visual Studio

  5. Jeśli zostanie wyświetlony monit, zezwól programowi Visual Studio na dostęp za pośrednictwem lokalnej zapory.

  6. Po wyświetleniu monitu o poświadczenia zamiast poświadczeń użytkownika lokalnego wybierz inne konto (więcej opcji w systemie Windows). Podaj wartości userName i userPWD z opublikowanego profilu dla adresu e-mail i hasła w oknie dialogowym uwierzytelniania w systemie Windows. Po nawiązaniu bezpiecznego połączenia z serwerem wdrażania wyświetlane są dostępne procesy.

    Wprowadzanie poświadczeń w programie Visual Studio

  7. Zaznacz pole wyboru Pokaż proces od wszystkich użytkowników , a następnie wybierz pozycję dotnet.exe i wybierz pozycję Dołącz. Po zakończeniu operacji dołączasz kod biblioteki klas języka C# uruchomiony w izolowanym procesie roboczym. W tym momencie możesz debugować aplikację funkcji w zwykły sposób.

Aby dołączyć zdalny debuger do aplikacji funkcji uruchomionej w procesie przy użyciu hosta usługi Functions:

  • Na karcie Publikowanie wybierz wielokropek (...) w sekcji Hosting, a następnie wybierz pozycję Dołącz debuger.

    Zrzut ekranu przedstawiający dołączanie debugera z programu Visual Studio.

Program Visual Studio łączy się z aplikacją funkcji i włącza zdalne debugowanie, jeśli nie jest jeszcze włączone. Lokalizuje również debuger i dołącza go do procesu hosta aplikacji. W tym momencie możesz debugować aplikację funkcji w zwykły sposób.

Wyłączanie zdalnego debugowania

Po zakończeniu zdalnego debugowania kodu należy wyłączyć zdalne debugowanie w witrynie Azure Portal. Zdalne debugowanie jest automatycznie wyłączone po 48 godzinach, jeśli zapomnisz.

  1. Na karcie Publikowanie w projekcie wybierz wielokropek (...) w sekcji Hosting, a następnie wybierz pozycję Otwórz w witrynie Azure Portal. Ta akcja powoduje otwarcie aplikacji funkcji w witrynie Azure Portal, w której wdrożono projekt.

  2. W aplikacji funkcji wybierz pozycję Konfiguracja w obszarze ustawienia, wybierz pozycję Ustawienia ogólne, ustaw opcję Debugowanie zdalne na Wyłączone, a następnie wybierz pozycję Zapisz, a następnie kontynuuj.

Po ponownym uruchomieniu aplikacji funkcji nie można już zdalnie łączyć się z procesami zdalnymi. Możesz użyć tej samej karty w witrynie Azure Portal, aby włączyć zdalne debugowanie poza programem Visual Studio.

Funkcje monitorowania

Zalecanym sposobem monitorowania wykonywania funkcji jest zintegrowanie aplikacji funkcji z usługą aplikacja systemu Azure Insights. Należy włączyć tę integrację podczas tworzenia aplikacji funkcji podczas publikowania programu Visual Studio.

Jeśli z jakiegoś powodu integracja nie została wykonana podczas publikowania, nadal należy włączyć integrację usługi Application Insights dla aplikacji funkcji na platformie Azure.

Aby dowiedzieć się więcej na temat monitorowania przy użyciu usługi Application Insights, zobacz Monitorowanie usługi Azure Functions.

Testowanie funkcji

W tej sekcji opisano sposób tworzenia projektu modelu przetwarzania języka C#, który można przetestować za pomocą narzędzia xUnit.

Testowanie usługi Azure Functions za pomocą języka C# w programie Visual Studio

1. Konfiguracja

Wykonaj następujące kroki, aby skonfigurować środowisko, w tym projekt aplikacji i funkcje, wymagane do obsługi testów:

  1. Tworzenie nowej aplikacji usługi Functions i nadaj jej nazwę Functions
  2. Utwórz funkcję HTTP na podstawie szablonu i nadaj jej nazwę MyHttpTrigger.
  3. Utwórz funkcję czasomierza na podstawie szablonu i nadaj mu nazwę MyTimerTrigger.
  4. Utwórz aplikację xUnit Test w rozwiązaniu i nadaj jej nazwę Functions.Tests. Usuń domyślne pliki testowe.
  5. Dodawanie odwołania z aplikacji testowej do microsoft.AspNetCore.Mvc za pomocą narzędzia NuGet
  6. Odwołaj się do aplikacji Functions z poziomu aplikacji Functions.Tests.

Po utworzeniu projektów można utworzyć klasy używane do uruchamiania testów automatycznych.

2. Tworzenie klas testowych

Każda funkcja przyjmuje wystąpienie do obsługi rejestrowania komunikatów ILogger . Niektóre testy nie rejestrują komunikatów lub nie mają wątpliwości co do sposobu implementowania rejestrowania. Inne testy muszą ocenić zarejestrowane komunikaty, aby określić, czy test przechodzi.

  1. Utwórz klasę o nazwie ListLogger, która zawiera wewnętrzną listę komunikatów do oceny podczas testowania. Aby zaimplementować wymagany ILogger interfejs, klasa potrzebuje zakresu. Poniższa klasa wyśmiewa zakres przypadków testowych do przekazania do ListLogger klasy.

  2. Utwórz nową klasę w projekcie Functions.Tests o nazwie NullScope.cs i dodaj następujący kod:

    using System;

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

        private NullScope() { }

        public void Dispose() { }
    }
}

  3. Utwórz klasę w projekcie Functions.Tests o nazwie ListLogger.cs i dodaj następujący kod:

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

    Klasa ListLogger implementuje następujące elementy członkowskie zgodnie z umową interfejsu ILogger :

    • BeginScope: Zakresy dodają kontekst do rejestrowania. W takim przypadku test wskazuje tylko wystąpienie statyczne w NullScope klasie, aby umożliwić działanie testu.

    • IsEnabled: podano wartość domyślną false .

    • Log: Ta metoda używa udostępnionej formatter funkcji do formatowania komunikatu, a następnie dodaje wynikowy tekst do Logs kolekcji.

    Kolekcja Logs jest wystąpieniem List<string> klasy i jest inicjowana w konstruktorze.

  4. Utwórz plik kodu w projekcie Functions.Tests o nazwie LoggerTypes.cs i dodaj następujący kod:

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

    Wyliczenie określa typ rejestratora używanego przez testy.

  5. Utwórz klasę w projekcie Functions.Tests o nazwie TestFactory.cs i dodaj następujący kod:

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

    Klasa TestFactory implementuje następujące elementy członkowskie:

    • Dane: ta właściwość zwraca kolekcję IEnumerable przykładowych danych. Pary wartości klucza reprezentują wartości, które są przekazywane do ciągu zapytania.

    • CreateDictionary: Ta metoda akceptuje parę klucz/wartość jako argumenty i zwraca nową Dictionary wartość używaną do QueryCollection reprezentowania wartości ciągu zapytania.

    • CreateHttpRequest: Ta metoda tworzy żądanie HTTP zainicjowane przy użyciu podanych parametrów ciągu zapytania.

    • CreateLogger: na podstawie typu rejestratora ta metoda zwraca klasę rejestratora używaną do testowania. Śledzenie ListLogger zarejestrowanych komunikatów dostępnych do oceny w testach.

  6. Utwórz klasę w projekcie Functions.Tests o nazwie FunctionsTests.cs i dodaj następujący kod:

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

    Elementy członkowskie zaimplementowane w tej klasie to:

    • Http_trigger_should_return_known_string: Ten test tworzy żądanie z wartościami name=Bill ciągu zapytania dla funkcji HTTP i sprawdza, czy zwracana jest oczekiwana odpowiedź.

    • Http_trigger_should_return_string_from_member_data: w tym teście są używane atrybuty xUnit w celu udostępnienia przykładowych danych funkcji HTTP.

    • Timer_should_log_message: Ten test tworzy wystąpienie ListLogger obiektu i przekazuje je do funkcji czasomierza. Po uruchomieniu funkcji dziennik jest sprawdzany, aby upewnić się, że oczekiwany komunikat jest obecny.

  7. Aby uzyskać dostęp do ustawień aplikacji w testach, możesz wstrzyknąć IConfiguration wystąpienie z wyśmiewanymi wartościami zmiennych środowiskowych do funkcji.

3. Uruchamianie testów

Aby uruchomić testy, przejdź do Eksploratora testów i wybierz pozycję Uruchom wszystkie testy w widoku.

Testowanie usługi Azure Functions za pomocą języka C# w programie Visual Studio

4. Debugowanie testów

Aby debugować testy, ustaw punkt przerwania w teście, przejdź do Eksploratora testów i wybierz pozycję Uruchom > debugowanie ostatnie.

Następne kroki

Aby uzyskać więcej informacji na temat narzędzi Azure Functions Core Tools, zobacz Praca z narzędziami Azure Functions Core Tools.

Przewodnik po modelu przetwarzania w języku C#

Przewodnik po modelu izolowanego procesu roboczego w języku C#