Hostowanie aplikacji Durable Functions w usłudze Azure Container Apps (izolowane środowisko .NET)

Usługa Azure Functions zapewnia zintegrowaną obsługę tworzenia, wdrażania i zarządzania konteneryzowanymi aplikacjami funkcji w usłudze Azure Container Apps. Użyj usługi Azure Container Apps dla aplikacji usługi Functions, gdy musisz uruchomić je w tym samym środowisku co inne mikrousługi, interfejsy API, witryny internetowe, przepływy pracy lub dowolne programy hostowane w kontenerze. Dowiedz się więcej o uruchamianiu usługi Azure Functions w usłudze Container Apps.

Uwaga / Notatka

Chociaż rozszerzenie Durable Functions obsługuje kilku dostawców magazynu lub zaplecza, aplikacje ze skalowaniem automatycznym hostowane w usłudze Azure Container Apps są dostępne wyłącznie z zapleczem Microsoft SQL (MSSQL). Jeśli jest używane inne zaplecze, należy ustawić minimalną liczbę replik na większą niż zero.

W tym artykule dowiesz się, jak:

• Utwórz obraz platformy Docker z lokalnego projektu durable functions.
• Utwórz aplikację kontenera platformy Azure i powiązane zasoby.
• Wdróż obraz w aplikacji kontenera platformy Azure i skonfiguruj uwierzytelnianie.

Wymagania wstępne

• Zainstalowany program Visual Studio Code .
• Zestaw .NET 8.0 SDK.
• Identyfikator platformy Docker i platformy Docker
• Interfejs wiersza polecenia platformy Azurew wersji 2.47 lub nowszej.
• Podstawowe narzędzia usługi Azure Functions
• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Narzędzie do testowania HTTP, które zapewnia bezpieczeństwo danych. Aby uzyskać więcej informacji, zobacz Narzędzia do testowania HTTP.

Tworzenie lokalnego projektu rozszerzenia Durable Functions

W programie Visual Studio Code utwórz izolowany projekt rozszerzenia Durable Functions platformy .NET skonfigurowany do korzystania z zaplecza MSSQL.

Przetestuj aplikację lokalnie i wróć do tego artykułu.

Dodawanie plików związanych z platformą Docker

Utwórz plik Dockerfile w katalogu głównym projektu, który opisuje minimalne wymagane środowisko do uruchomienia aplikacji funkcji w kontenerze.

1. W katalogu głównym projektu utwórz nowy plik o nazwie Dockerfile.

2. Skopiuj/wklej następującą zawartość do pliku Dockerfile.

   FROM mcr.microsoft.com/dotnet/sdk:8.0 AS installer-env
   
   COPY . /src/dotnet-function-app
   RUN cd /src/dotnet-function-app && \
   mkdir -p /home/site/wwwroot && \
   dotnet publish *.csproj --output /home/site/wwwroot
   
   # To enable ssh & remote debugging on app service change the base image to the one below
   # FROM mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0-appservice
   FROM mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0
   ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
       AzureFunctionsJobHost__Logging__Console__IsEnabled=true
   
   COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]
   

3. Zapisz plik.

4. Dodaj plik dockerignore o następującej zawartości:

   local.settings.json
   

5. Zapisz plik .dockerignore .

Kompilowanie obrazu kontenera

Zbuduj obraz platformy Docker. Znajdź pełną listę obsługiwanych obrazów bazowych dla usługi Azure Functions w bazie usługi Azure Functions firmy Microsoft | Docker Hub

1. Uruchom demona Docker.

2. Zaloguj się do Docker za pomocą polecenia docker login.

3. Po wyświetleniu monitu zaloguj się przy użyciu nazwy użytkownika i hasła. Komunikat "Logowanie powiodło się" potwierdza, że zalogowałeś się.

4. Przejdź do katalogu głównego projektu.

5. Uruchom następujące polecenie, aby skompilować obraz, zastępując <DOCKER_ID> element identyfikatorem konta usługi Docker Hub:

   dockerId=<DOCKER_ID>
   imageName=IMAGE_NAME>
   imageVersion=v1.0.0
   
   docker build --tag $dockerId/$imageName:$imageVersion .
   

   Uwaga / Notatka

   Jeśli korzystasz z komputera Mac z serii M, użyj --platform linux/amd64 zamiast tego.

6. Wypchnij obraz do platformy Docker:

   docker push $dockerId/$imageName:$imageVersion
   

   W zależności od szybkości sieci początkowe przesyłanie obrazu może potrwać kilka minut. Czekając, przejdź do następnej sekcji.

Tworzenie zasobów platformy Azure

Utwórz zasoby platformy Azure niezbędne do uruchamiania rozszerzenia Durable Functions w aplikacji kontenera.

• Grupa zasobów platformy Azure: Grupa zasobów zawierająca wszystkie utworzone zasoby.
• Środowisko aplikacji kontenera platformy Azure: Środowisko hostowania aplikacji kontenera.
• Aplikacja kontenerowa Azure: Obraz zawierający aplikację Durable Functions jest wdrażany w ramach tej aplikacji.
• Konto usługi Azure Storage: Wymagane przez aplikację funkcji do przechowywania danych związanych z aplikacją, takich jak kod aplikacji.

Początkowa konfiguracja

1. W nowym terminalu zaloguj się do subskrypcji platformy Azure:

   az login  
   
   az account set -s <subscription_name>
   

2. Uruchom wymagane polecenia, aby skonfigurować rozszerzenie interfejsu wiersza polecenia usługi Azure Container Apps:

   az upgrade
   
   az extension add --name containerapp --upgrade
   
   az provider register --namespace Microsoft.App
   
   az provider register --namespace Microsoft.OperationalInsights
   

Tworzenie aplikacji kontenera i powiązanych zasobów

Profil obciążenia określa ilość zasobów obliczeniowych i pamięci dostępnych dla aplikacji kontenera wdrożonych w środowisku. Utwórz profil obciążenia dla zużycia na potrzeby obsługi skalowania do zera i modelu płatności za rzeczywiste użycie.

1. Ustaw zmienne środowiskowe.

   location=<REGION>
   resourceGroup=<RESOURCE_GROUP_NAME>
   storage=<STORAGE_NAME>
   containerAppEnv=<CONTAINER_APP_ENVIRONMNET_NAME>
   functionApp=<APP_NAME>
   vnet=<VNET_NAME>
   

2. Utwórz grupę zasobów.

   az group create --name $resourceGroup --location $location
   

3. Utwórz środowisko aplikacji kontenera.

   az containerapp env create \
     --enable-workload-profiles \
     --resource-group $resourceGroup \
     --name $containerAppEnv \
     --location $location \
   

4. Utwórz aplikację kontenerową na podstawie obrazu Durable Functions.

   az containerapp create --resource-group $resourceGroup \
   --name $functionApp \
   --environment $containerAppEnv \
   --image $dockerId/$imageName:$imageVersion \
   --ingress external \
   --kind functionapp \
   --query properties.outputs.fqdn
   

5. Zanotuj adres URL aplikacji, który powinien wyglądać podobnie do https://<APP_NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io.

Tworzenie baz danych

1. Utwórz konto usługi Azure Storage, które jest wymagane przez aplikację funkcji.

   az storage account create --name $storage --location $location --resource-group $resourceGroup --sku Standard_LRS
   

2. W witrynie Azure Portal utwórz bazę danych Azure SQL Database w celu utrwalania informacji o stanie. Podczas tworzenia:

   • Włączanie usług i zasobów platformy Azure w celu uzyskania dostępu do tego serwera (w obszarze Sieć)
   • Ustaw wartość dla sortowania bazy danych (w obszarze Ustawienia dodatkowe) na Latin1_General_100_BIN2_UTF8.

Uwaga / Notatka

Powstrzymaj się od włączenia opcji Zezwalaj usługom i zasobom platformy Azure na dostęp do tego ustawienia serwera dla scenariuszy produkcyjnych. Aplikacje produkcyjne powinny implementować bezpieczniejsze podejścia, takie jak silniejsze ograniczenia zapory lub konfiguracje sieci wirtualnej.

Konfigurowanie uwierzytelniania opartego na tożsamościach

Tożsamości zarządzane sprawiają, że aplikacja jest bezpieczniejsza, usuwając sekrety z aplikacji, takie jak dane uwierzytelniające w łańcuchach połączeń. Chociaż można wybrać między tożsamością zarządzaną przypisaną przez system i przypisaną przez użytkownika, zalecana jest tożsamość zarządzana przypisana przez użytkownika, ponieważ nie jest powiązana z cyklem życia aplikacji.

W tej sekcji skonfigurujesz tożsamość zarządzaną przypisaną przez użytkownika dla usługi Azure Storage.

1. Ustaw zmienne środowiskowe.

   subscription=<SUBSCRIPTION_ID>
   identity=<IDENTITY_NAME>
   

2. Utwórz zasób tożsamości zarządzanej.

   echo "Creating $identity"
   az identity create -g $resourceGroup -n $identity --location "$location"
   

3. Przypisz tożsamość użytkownika do aplikacji kontenera.

   echo "Assigning $identity to app"
   az containerapp identity assign --resource-group $resourceGroup --name $functionApp --user-assigned $identity
   

4. Ustaw zakres uprawnień kontroli dostępu opartej na rolach (RBAC).

   scope="/subscriptions/$subscription/resourceGroups/$resourceGroup/providers/Microsoft.Storage/storageAccounts/$storage"
   

5. Pobierz tożsamość użytkownika clientId.

   # Get the identity's ClientId 
   clientId=$(az identity show --name $identity --resource-group $resourceGroup --query 'clientId' --output tsv)
   

6. Przypisz rolę Storage Blob Data Owner, aby uzyskać dostęp do konta magazynu.

   echo "Assign Storage Blob Data Owner role to identity"
   az role assignment create --assignee "$clientId" --role "Storage Blob Data Owner" --scope "$scope"
   

Konfigurowanie ustawień aplikacji

Uwaga / Notatka

Uwierzytelnianie w bazie danych MSSQL przy użyciu tożsamości zarządzanej nie jest obsługiwane podczas hostowania aplikacji Durable Functions w usłudze Azure Container Apps. Na razie ten przewodnik uwierzytelnia się przy użyciu parametrów połączenia.

1. W zasobie bazy danych SQL w witrynie Azure Portal przejdź do pozycji Ustawienia>Parametry połączenia , aby znaleźć parametry połączenia.

   

   Parametry połączenia powinny mieć format podobny do:

   dbserver=<SQL_SERVER_NAME>
   sqlDB=<SQL_DB_NAME>
   username=<DB_USER_LOGIN>
   password=<DB_USER_PASSWORD>
   
   connStr="Server=tcp:$dbserver.database.windows.net,1433;Initial Catalog=$sqlDB;Persist Security Info=False;User ID=$username;Password=$password;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
   

   Jeśli zapomnisz hasło z poprzedniego kroku tworzenia bazy danych, możesz zresetować je w zasobie programu SQL Server.

   

2. Zapisz parametry połączenia bazy danych SQL jako wpis tajny o nazwie sqldbconnection w aplikacji kontenera.

   az containerapp secret set \
   --resource-group $resourceGroup \
   --name $functionApp \
   --secrets sqldbconnection=$connStr
   

3. Dodaj następujące ustawienia do aplikacji:

   az containerapp update \
   -n $functionApp \
   -g $resourceGroup \
   --set-env-vars SQLDB_Connection=secretref:sqldbconnection \
   AzureWebJobsStorage__accountName=$storage \
   AzureWebJobsStorage__clientId=$clientId \
   AzureWebJobsStorage__credential=managedidentity \
   FUNCTIONS_WORKER_RUNTIME=dotnet-isolated
   

Testowanie lokalne

1. Użyj narzędzia do testowania HTTP, aby wysłać POST żądanie do punktu końcowego wyzwalacza HTTP, który powinien być podobny do następującego:

   https://<APP NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io/api/DurableFunctionsOrchestrationCSharp1_HttpStart
   

   Odpowiedź to początkowy wynik funkcji HTTP informujący o tym, że aranżacja rozszerzenia Durable Functions została pomyślnie uruchomiona. Chociaż odpowiedź zawiera kilka przydatnych adresów URL, nie wyświetla jeszcze wyniku końcowego aranżacji.

2. Skopiuj/wklej wartość adresu URL na statusQueryGetUri pasku adresu przeglądarki i wykonaj polecenie . Alternatywnie możesz nadal używać narzędzia do testowania HTTP, aby wysłać GET żądanie.

   Żądanie wysyła zapytanie do wystąpienia orkiestracji dla stanu. Powinno zostać wyświetlone, że wystąpienie zostało zakończone, a wyniki lub dane wyjściowe z aplikacji Durable Functions.

   {
       "name":"HelloCities",
       "instanceId":"7f99f9474a6641438e5c7169b7ecb3f2",
       "runtimeStatus":"Completed",
       "input":null,
       "customStatus":null,
       "output":"Hello, Tokyo! Hello, London! Hello, Seattle!",
       "createdTime":"2023-01-31T18:48:49Z",
       "lastUpdatedTime":"2023-01-31T18:48:56Z"
   }
   

Dalsze kroki

Dowiedz się więcej o:

• Usługa Azure Container Apps hostująca usługę Azure Functions.
• Architektura, konfiguracja i działanie magazynu danych dostawcy MSSQL.
• Zaplecze magazynowania zarządzane przez platformę Azure, Durable Task Scheduler.