Tworzenie i uruchamianie kodu platformy .NET na podstawie standardowych przepływów pracy w usłudze Azure Logic Apps

Artykuł
06/18/2024

Dotyczy: Azure Logic Apps (Standardowa)

W przypadku rozwiązań integracji, w których musisz tworzyć i uruchamiać kod .NET z przepływu pracy aplikacji logiki w warstwie Standardowa, możesz użyć programu Visual Studio Code z rozszerzeniem Azure Logic Apps (Standard). To rozszerzenie zapewnia następujące możliwości i korzyści:

Napisz własny kod, tworząc funkcje, które mają elastyczność i kontrolę w celu rozwiązania najbardziej trudnych problemów z integracją.
Lokalne debugowanie kodu w programie Visual Studio Code. Wykonaj kroki kodu i przepływów pracy w tej samej sesji debugowania.
Wdróż kod obok przepływów pracy. Nie są potrzebne żadne inne plany usług.
Obsługa scenariuszy migracji programu BizTalk Server, dzięki czemu można przenieść niestandardowe inwestycje platformy .NET ze środowiska lokalnego do chmury.

Dzięki możliwości pisania własnego kodu można wykonać scenariusze, takie jak:

Niestandardowa implementacja logiki biznesowej
Analizowanie niestandardowe w celu wyodrębnienia informacji z komunikatu przychodzącego
Walidacja danych i proste przekształcenia
Kształtowanie komunikatów dla komunikatów wychodzących do innego systemu, takiego jak interfejs API
Obliczenia

Ta funkcja nie jest odpowiednia w scenariuszach, takich jak następujące:

Uruchamianie procesów, które potrwają ponad 10 minut
Duże przekształcenia komunikatów i danych
Złożone scenariusze przetwarzania wsadowego i debatowania
Składniki potoku programu BizTalk Server implementujące przesyłanie strumieniowe

Aby uzyskać więcej informacji na temat ograniczeń w usłudze Azure Logic Apps, zobacz Limity i konfiguracja — Azure Logic Apps.

Wymagania wstępne

Konto i subskrypcja platformy Azure. Jeśli nie masz subskrypcji, zarejestruj się w celu założenia bezpłatnego konta platformy Azure.
Najnowszy program Visual Studio Code z rozszerzeniem azure Logic Apps (Standard). Aby spełnić te wymagania, zobacz wymagania wstępne dotyczące tworzenia standardowych przepływów pracy w usłudze Azure Logic Apps z jedną dzierżawą przy użyciu programu Visual Studio Code.
- Funkcja niestandardowa jest obecnie dostępna tylko w programie Visual Studio Code uruchomionym w systemie operacyjnym Windows.
- Funkcja niestandardowa obsługuje obecnie wywoływanie środowisk .NET Framework i .NET 8 dla przepływów pracy aplikacji logiki hostowanej na platformie Azure.
Folder lokalny używany do tworzenia projektu kodu

Ograniczenia

Tworzenie funkcji niestandardowych nie jest obecnie dostępne w witrynie Azure Portal. Jednak po wdrożeniu funkcji z programu Visual Studio Code na platformę Azure wykonaj kroki opisane w temacie Wywoływanie kodu z przepływu pracy dla witryny Azure Portal. Możesz użyć wbudowanej akcji o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki, aby wybrać z wdrożonych funkcji niestandardowych i uruchomić kod. Kolejne akcje w przepływie pracy mogą odwoływać się do danych wyjściowych z tych funkcji, tak jak w każdym innym przepływie pracy. Możesz wyświetlić wbudowaną historię uruchamiania, dane wejściowe i wyjściowe akcji wbudowanej.

Tworzenie projektu kodu

Najnowsze rozszerzenie usługi Azure Logic Apps (Standard) dla programu Visual Studio Code zawiera szablon projektu kodu, który zapewnia usprawnione środowisko pisania, debugowania i wdrażania własnego kodu przy użyciu przepływów pracy. Ten szablon projektu tworzy plik obszaru roboczego i dwa przykładowe projekty: jeden projekt do pisania kodu, drugi projekt do tworzenia przepływów pracy.

Uwaga

Nie można użyć tego samego folderu projektu zarówno dla kodu, jak i przepływów pracy.

Otwórz Visual Studio Code. Na pasku działań wybierz ikonę platformy Azure . (Klawiatura: Shift+Alt+A)
W wyświetlonym oknie platformy Azure na pasku narzędzi sekcji Obszar roboczy z menu Azure Logic Apps wybierz pozycję Utwórz nowy obszar roboczy aplikacji logiki.
W polu Wybierz folder przejdź do folderu lokalnego utworzonego dla projektu i wybierz go.
Po wyświetleniu okna monitu Tworzenie nowego obszaru roboczego aplikacji logiki podaj nazwę obszaru roboczego:

Ten przykład jest kontynuowany w usłudze MyLogicAppWorkspace.
Po wyświetleniu okna monitu Wybieranie szablonu projektu dla obszaru roboczego aplikacji logiki wybierz pozycję Aplikacja logiki z niestandardowym projektem kodu.
W przypadku przepływów pracy aplikacji logiki hostowanej w warstwie Standardowa platformy Azure postępuj zgodnie z monitem, aby wybrać program .NET Framework lub .NET 8.

Postępuj zgodnie z kolejnymi monitami, aby podać następujące przykładowe wartości:

Towar	Przykładowa wartość
Nazwa funkcji projektu funkcji platformy .NET	WeatherForecast
Nazwa przestrzeni nazw projektu funkcji platformy .NET	Contoso.Enterprise
Szablon przepływu pracy: - Stanowy przepływ pracy - Przepływ pracy bezstanowy	Stanowy przepływ pracy
Nazwa przepływu pracy	MyWorkflow

Wybierz pozycję Otwórz w bieżącym oknie.

Po zakończeniu tego kroku program Visual Studio Code tworzy obszar roboczy, który obejmuje projekt funkcji platformy .NET i projekt aplikacji logiki, na przykład:

Zrzut ekranu przedstawiający program Visual Studio Code z utworzonym obszarem roboczym.

Węzeł	opis
*<nazwa obszaru roboczego>*	Zawiera zarówno projekt funkcji platformy .NET, jak i projekt przepływu pracy aplikacji logiki.
Funkcje	Zawiera artefakty projektu funkcji platformy .NET. Na przykład *<plik nazwa-funkcji>.cs* to plik kodu, w którym można utworzyć kod.
LogicApp	Zawiera artefakty dla projektu aplikacji logiki, w tym pusty przepływ pracy.

Pisanie kodu

W obszarze roboczym rozwiń węzeł Funkcje , jeśli jeszcze nie został rozszerzony.

<Otwórz plik function-name>.cs o nazwie WeatherForecast.cs w tym przykładzie.

Domyślnie ten plik zawiera przykładowy kod, który zawiera następujące elementy kodu wraz z wcześniej podanymi przykładowymi wartościami w odpowiednich przypadkach:

Nazwa przestrzeni nazw
Nazwa klasy
Nazwa funkcji
Parametry funkcji
Typ zwracany
Typ złożony

Poniższy przykład przedstawia kompletny przykładowy kod:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso.Enterprise
{
    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using Microsoft.Azure.Functions.Extensions.Workflows;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Extensions.Logging;

    /// <summary>
    /// Represents the WeatherForecast flow invoked function.
    /// </summary>
    public class WeatherForecast
    {

        private readonly ILogger<WeatherForecast> logger;

        public WeatherForecast(ILoggerFactory loggerFactory)
        {
            logger = loggerFactory.CreateLogger<WeatherForecast>();
        }

        /// <summary>
        /// Executes the logic app workflow.
        /// </summary>
        /// <param name="zipCode">The zip code.</param>
        /// <param name="temperatureScale">The temperature scale (e.g., Celsius or Fahrenheit).</param>
        [FunctionName("WeatherForecast")]
        public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
        {

            this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

            // Generate random temperature within a range based on the temperature scale
            Random rnd = new Random();
            var currentTemp = temperatureScale == "Celsius" ? rnd.Next(1, 30) : rnd.Next(40, 90);
            var lowTemp = currentTemp - 10;
            var highTemp = currentTemp + 10;

            // Create a Weather object with the temperature information
            var weather = new Weather()
            {
                ZipCode = zipCode,
                CurrentWeather = $"The current weather is {currentTemp} {temperatureScale}",
                DayLow = $"The low for the day is {lowTemp} {temperatureScale}",
                DayHigh = $"The high for the day is {highTemp} {temperatureScale}"
            };

            return Task.FromResult(weather);
        }

        /// <summary>
        /// Represents the weather information for WeatherForecast.
        /// </summary>
        public class Weather
        {
            /// <summary>
            /// Gets or sets the zip code.
            /// </summary>
            public int ZipCode { get; set; }

            /// <summary>
            /// Gets or sets the current weather.
            /// </summary>
            public string CurrentWeather { get; set; }

            /// <summary>
            /// Gets or sets the low temperature for the day.
            /// </summary>
            public string DayLow { get; set; }

            /// <summary>
            /// Gets or sets the high temperature for the day.
            /// </summary>
            public string DayHigh { get; set; }
        }
    }
}

Definicja funkcji zawiera domyślną Run metodę, której można użyć do rozpoczęcia pracy. Ta przykładowa Run metoda demonstruje niektóre funkcje dostępne w funkcji niestandardowych, takie jak przekazywanie różnych danych wejściowych i wyjściowych, w tym złożonych typów platformy .NET.

Plik <nazwa-funkcji>.cs zawiera ILogger również interfejs, który zapewnia obsługę rejestrowania zdarzeń do zasobu usługi Application Insights. Możesz wysyłać informacje śledzenia do usługi Application Insights i przechowywać te informacje wraz z informacjami śledzenia z przepływów pracy, na przykład:

private readonly ILogger<WeatherForecast> logger;

public WeatherForecast(ILoggerFactory loggerFactory)
{
    logger = loggerFactory.CreateLogger<WeatherForecast>();
}

[FunctionName("WeatherForecast")]
public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
{

    this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

    <...>

}

Zastąp przykładowy kod funkcji własnym kodem i zmodyfikuj domyślną Run metodę dla własnych scenariuszy. Możesz też skopiować funkcję, w tym deklarację [FunctionName("<*function-name*>")] , a następnie zmienić nazwę funkcji na unikatową nazwę. Następnie możesz edytować zmienioną nazwę funkcji w celu spełnienia Twoich potrzeb.

W tym przykładzie kod przykładowy jest kontynuowany bez żadnych zmian.

Kompilowanie i kompilowanie kodu

Po zakończeniu pisania kodu skompiluj, aby upewnić się, że nie istnieją żadne błędy kompilacji. Projekt funkcji platformy .NET automatycznie zawiera zadania kompilacji, które kompilują, a następnie dodają kod do folderu lib\custom w projekcie aplikacji logiki, w którym przepływy pracy szukają funkcji niestandardowych do uruchomienia. Te zadania umieszczają zestawy w folderze lib\custom\net472 lub lib\custom\net8 na podstawie wersji platformy .NET.

W programie Visual Studio Code z menu Terminal wybierz pozycję Nowy terminal.
Z wyświetlonej listy katalogów roboczych wybierz pozycję Funkcje jako bieżący katalog roboczy dla nowego terminalu.

Program Visual Studio Code otwiera okno terminalu z wierszem polecenia.
W oknie Terminal w wierszu polecenia wprowadź polecenie dotnet restore.

Program Visual Studio Code analizuje projekty i określa, czy są aktualne.
Po ponownym wyświetleniu wiersza polecenia wprowadź polecenie dotnet build. Z menu Terminal wybierz pozycję Uruchom zadanie. Z listy zadań wybierz pozycję Build (Functions).

Jeśli kompilacja zakończy się pomyślnie, okno terminalu zgłosi, że kompilacja zakończyła się pomyślnie.
Upewnij się, że w projekcie aplikacji logiki istnieją następujące elementy:
- W obszarze roboczym rozwiń następujące foldery: LogicApp>lib\custom>net472 lub net8 na podstawie wersji platformy .NET. Upewnij się, że podfolder o nazwie net472 lub net8 zawiera odpowiednio pliki zestawu (DLL) wymagane do uruchomienia kodu, w tym plik o nazwie< nazwa-funkcji>.dll.
- W obszarze roboczym rozwiń następujące foldery: LogicApp>lib\custom<>function-name.> Upewnij się, że podfolder o nazwie <function-name> zawiera plik function.json zawierający metadane dotyczące napisanego kodu funkcji. Projektant przepływu pracy używa tego pliku do określenia niezbędnych danych wejściowych i wyjściowych podczas wywoływania kodu.
W poniższym przykładzie pokazano przykładowe wygenerowane zestawy i inne pliki w projekcie aplikacji logiki:

Wywoływanie kodu z przepływu pracy

Po potwierdzeniu, że kod zostanie skompilowany i że projekt aplikacji logiki zawiera niezbędne pliki do uruchomienia kodu, otwórz domyślny przepływ pracy dołączony do projektu aplikacji logiki.

W obszarze roboczym w obszarze LogicApp rozwiń <węzeł nazwa> przepływu pracy, otwórz menu skrótów dla workflow.json, a następnie wybierz pozycję Otwórz projektanta.

W wyświetlonym projektancie przepływu pracy domyślny przepływ pracy dołączony do projektu aplikacji logiki jest wyświetlany z następującym wyzwalaczem i akcjami:
- Wbudowany wyzwalacz żądania o nazwie Po odebraniu żądania HTTP
- Wbudowana akcja o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki
- Wbudowana akcja Odpowiedź o nazwie Odpowiedź, która służy do odpowiadania na obiekt wywołujący tylko wtedy, gdy używasz wyzwalacza Żądania
Wybierz akcję o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki.

Okienko informacji o akcji zostanie otwarte po prawej stronie.
Przejrzyj i upewnij się, że wartość parametru Nazwa funkcji jest ustawiona na funkcję, którą chcesz uruchomić. Przejrzyj lub zmień inne wartości parametrów używane przez funkcję.

Debugowanie kodu i przepływu pracy

Powtórz następujące kroki, aby uruchomić emulator magazynu Azurite trzy razy: jeden raz dla następujących usług Azure Storage:
- Azure Blob Service
- Usługa kolejek systemu Azure
- Azure Table Service
1. Z menu Widok programu Visual Studio Code wybierz pozycję Paleta poleceń.
2. Po wyświetleniu monitu znajdź i wybierz pozycję Azurite: Uruchom usługę Blob Service.
3. Z wyświetlonej listy katalogów roboczych wybierz pozycję LogicApp.
4. Powtórz następujące kroki dla usługi Azurite: Uruchom usługę Kolejki i Azurite: Uruchom usługę Table Service.
Po pomyślnym zakończeniu działania paska zadań programu Visual Studio Code w dolnej części ekranu są wyświetlane trzy uruchomione usługi magazynu, na przykład:
Dołącz debuger do projektu aplikacji logiki, wykonując następujące kroki:
1. Na pasku działań programu Visual Studio Code wybierz pozycję Uruchom i debuguj. (Klawiatura: Ctrl+Shift+D)
2. Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do aplikacji logiki (LogicApp), jeśli nie została jeszcze wybrana, a następnie wybierz pozycję Odtwórz (zielona strzałka).
  
  Zostanie otwarte okno Terminal i zostanie wyświetlone rozpoczęty proces debugowania. Zostanie wyświetlone okno Konsola debugowania i zostanie wyświetlone stany debugowania. W dolnej części programu Visual Studio Code pasek zadań zmieni kolor pomarańczowy, co oznacza, że debuger platformy .NET jest ładowany.
Dołącz debuger do projektu funkcji platformy .NET, wykonując następujące kroki na podstawie kodu:

Projekty platformy .NET 8
1. Z menu Widok programu Visual Studio Code wybierz pozycję Paleta poleceń.
2. Z palety poleceń znajdź i wybierz pozycję Debuguj: Dołącz do procesu .NET 5 lub .NET Core.
3. Z listy znajdź i wybierz proces dotnet.exe . Jeśli istnieje wiele procesów dotnet.exe , wybierz proces, który ma następującą ścieżkę:
  
  <drive-name>:\Users<user-name.azure-functions-core-tools>\Functions\ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows<extension-bundle-version>\CustomCodeNetFxWorker\net8\Microsoft.Azure.Workflows.Functions.CustomCodeNetFxWorker.dll
Projekty programu .NET Framework

Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do funkcji platformy .NET (Funkcje), jeśli nie została jeszcze wybrana, a następnie wybierz pozycję Odtwórz (zielona strzałka).
Aby ustawić wszystkie punkty przerwania, w definicji funkcji (<nazwa-funkcji>.cs) lub definicji przepływu pracy (workflow.json) znajdź numer wiersza, w którym chcesz punkt przerwania, a następnie wybierz kolumnę z lewej strony, na przykład:
Aby ręcznie uruchomić wyzwalacz żądania w przepływie pracy, otwórz stronę Przegląd przepływu pracy.
1. W projekcie aplikacji logiki otwórz menu skrótów pliku workflow.json i wybierz pozycję Przegląd.
  
  Na stronie Przegląd przepływu pracy przycisk Uruchom wyzwalacz jest dostępny, gdy chcesz ręcznie uruchomić przepływ pracy. W obszarze Właściwości przepływu pracy wartość adresu URL wywołania zwrotnego to adres URL punktu końcowego z możliwością wywołania, który jest tworzony przez wyzwalacz Żądania w przepływie pracy. Możesz wysyłać żądania do tego adresu URL w celu wyzwolenia przepływu pracy z innych aplikacji, w tym innych przepływów pracy aplikacji logiki.
Na pasku narzędzi strony Przegląd wybierz pozycję Uruchom wyzwalacz.

Po uruchomieniu przepływu pracy debuger aktywuje swój pierwszy punkt przerwania.
Na pasku narzędzi Uruchom menu lub debugera wybierz akcję debugowania.

Po zakończeniu przebiegu przepływu pracy na stronie Przegląd zostanie wyświetlony ukończony przebieg i podstawowe informacje o tym przebiegu.
Aby przejrzeć więcej informacji na temat przebiegu przepływu pracy, wybierz ukończone uruchomienie. Lub z listy obok kolumny Czas trwania wybierz pozycję Pokaż przebieg.

Wdrażanie kodu

Funkcje niestandardowe można wdrożyć w taki sam sposób, jak w przypadku wdrażania projektu aplikacji logiki. Niezależnie od tego, czy wdrażasz program Visual Studio Code, czy korzystasz z procesu ciągłej integracji/ciągłego wdrażania DevOps, przed wdrożeniem upewnij się, że kod jest kompilowany i że wszystkie zależne zestawy istnieją w następującym folderze projektu aplikacji logiki:

.NET 4.7.2: folder lib/custom/net472
.NET 8: folder lib/custom/net8

Aby uzyskać więcej informacji, zobacz Wdrażanie standardowych przepływów pracy z programu Visual Studio Code na platformę Azure.

Rozwiązywanie problemów

Błąd okienka informacji o akcjach

W projektancie przepływu pracy po wybraniu wbudowanej akcji o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki okienko informacji akcji wyświetla następujący komunikat:

Failed to retrieve dynamic inputs. Error details:

W tym scenariuszu sprawdź projekt aplikacji logiki, aby sprawdzić, czy folder LogicApp\lib\custom jest pusty. Jeśli jest pusty, w menu Terminal wybierz pozycję Uruchom funkcje kompilacji zadania>.

Brak procesu o określonej nazwie jest obecnie uruchomiony

Jeśli ten komunikat o błędzie zostanie wyświetlony podczas uruchamiania przepływu pracy, prawdopodobnie masz proces debugera dołączony do usługi .NET Functions, a nie do aplikacji logiki.

Aby rozwiązać ten problem, z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do aplikacji logiki (LogicApp),a następnie wybierz pozycję Odtwórz (zielony trójkąt).

Pakiet nie został poprawnie zaimportowany

Jeśli w oknie Dane wyjściowe zostanie wyświetlony błąd podobny do poniższego komunikatu, upewnij się, że zainstalowano co najmniej platformę .NET 6.0. Jeśli masz zainstalowaną tę wersję, spróbuj odinstalować, a następnie zainstalować ponownie.

C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.targets(83,5): warning : The ExtensionsMetadataGenerator package was not imported correctly. Are you missing 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.targets' or 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.props'? [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] WeatherForecast -> C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\\bin\Debug\net472\WeatherForecast.dll C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : It was not possible to find any compatible framework version [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : The specified framework 'Microsoft.NETCore.App', version '6.0.0' was not found. [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : - Check application dependencies and target a framework version installed at: [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj]

Błędy kompilacji

Jeśli funkcja nie zawiera zmiennych i skompilujesz kod, w oknie Dane wyjściowe mogą być wyświetlane następujące komunikaty o błędach:

C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1031: Type expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]
C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1001: Identifier expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]

Build FAILED.

0 Warning(s)
2 Error(s)

Aby rozwiązać ten problem, w metodzie kodu Run dołącz następujący parametr:

string parameter1 = null

W poniższym przykładzie pokazano, jak Run pojawia się podpis metody:

public static Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale, string parameter1 = null)

Następne kroki

Tworzenie standardowych przepływów pracy za pomocą programu Visual Studio Code

Udostępnij za pośrednictwem