Använd en Durable Functions-app med MSSQL-backend i Azure Container Apps (.NET isolerad)

Azure Container Apps är det enda värdalternativet som stöder händelsedriven autoskalning (skala till noll) för Durable Functions när du använder lagringsprovidern Microsoft SQL (MSSQL). Om du använder en annan lagringsserverdel måste du ange det minsta antalet repliker till större än noll.

Tips/Råd

För nya projekt bör du överväga att använda Durable Task Scheduler, vilket är den rekommenderade Azure hanterade serverdelen för hållbara arbetsflöden. Den här guiden beskriver specifikt MSSQL-serverdelen.

Mer information om hur du kör Azure Functions i Container Apps finns i Azure Container Apps värd för Azure Functions.

I den här artikeln lär du dig att:

Skapa en Docker-avbildning från ett lokalt Durable Functions-projekt.
Skapa en Azure Container App och relaterade resurser.
Distribuera avbildningen till Azure Container App och konfigurera autentisering.

Förutsättningar

Visual Studio Code installerat.
.NET 8.0 SDK.
Docker - och Docker-ID
Azure CLI version 2.47 eller senare.
Azure Functions Core Tools
Azure-konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt.
Ett HTTP-testverktyg som skyddar dina data. Mer information finns i HTTP-testverktyg.

Skapa ett lokalt Durable Functions-projekt

Den här guiden förutsätter att du har ett fungerande .NET isolerat Durable Functions projekt som konfigurerats med MSSQL-serverdelen. Om du inte har någon ännu följer du snabbstarten för MSSQL för att skapa och testa en lokalt och gå sedan tillbaka hit.

Innan du fortsätter kontrollerar du att:

Projektet är inriktat på .NET 8.0 och använder den isolerade arbetsmodellen
MSSQL-lagringsprovidern är konfigurerad i host.json
Appen körs framgångsrikt med func start

Skapa en Dockerfile i projektroten som beskriver den minsta miljö som krävs för att köra funktionsappen i en container.

Skapa en ny fil med namnet Dockerfile i projektrotkatalogen.

Kopiera/klistra in följande innehåll i 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"]

Spara filen.
Lägg till en .dockerignore-fil med följande innehåll:
```
local.settings.json
```
Spara .dockerignorefilen.

Bygga containeravbildningen

Skapa Docker-avbildningen. Hitta den fullständiga listan över basavbildningar som stöds för Azure Functions i Azure Functions Base av Microsoft | Docker Hub

Starta Docker-daemonen.
Logga in på Docker med docker login kommandot .
Logga in med ditt användarnamn och lösenord när du uppmanas att göra det. Ett meddelande om att inloggningen lyckades bekräftar att du är inloggad.
Gå till projektets rotkatalog.
Kör följande kommando för att skapa avbildningen och ersätt <DOCKER_ID> med ditt Docker Hub-konto-ID:
```
dockerId=<DOCKER_ID>
imageName=<IMAGE_NAME>
imageVersion=v1.0.0

docker build --tag $dockerId/$imageName:$imageVersion .
```
Anmärkning

Om du kör på en Mac i M-serien använder du --platform linux/amd64 i stället.
Skicka avbildningen till Docker:
```
docker push $dockerId/$imageName:$imageVersion
```
Beroende på nätverkets hastighet kan den första avbildnings push-överföringen ta några minuter. Fortsätt till nästa avsnitt medan du väntar.

Skapa Azure resurser för Durable Functions i Container Apps

Skapa de Azure-resurser som krävs för att köra Durable Functions i en containerapp.

Azure-resursgrupp: Resursgrupp som innehåller alla skapade resurser.
Azure Container App-miljö: Miljö som är värd för containerappen.
Azure Container App: Avbildning som innehåller Durable Functions-appen distribueras till den här appen.
Azure Storage-konto: Krävs av funktionsappen för att lagra apprelaterade data, till exempel programkod.

Första installationen

Logga in på din Azure-prenumeration i en ny terminal:
```
az login  

az account set -s <subscription_name>
```

Kör de kommandon som krävs för att konfigurera Azure Container Apps CLI-tillägget:

az upgrade

az extension add --name containerapp --upgrade

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

En arbetsbelastningsprofil avgör mängden beräknings- och minnesresurser som är tillgängliga för de containerappar som distribueras i en miljö. Skapa en förbrukningsarbetslägesprofil för stöd för skalning till noll och betalning per användning.

Ange miljövariablerna.

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

Skapa en resursgrupp.

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

Skapa containerappmiljön.

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

Skapa en containerapp baserat på Durable Functions-avbildningen.

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

Anteckna appens URL, som ungefär ser ut som https://<APP_NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io.

Skapa databaser

Skapa ett Azure Storage-konto som krävs av funktionsappen.

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

I Azure-portalen skapar du en Azure SQL-databas för att spara tillståndsinformation. När du skapar:
- Aktivera Azure tjänster och resurser för åtkomst till den här servern (under Nätverk). Använd starkare brandväggsbegränsningar eller konfigurationer av virtuella nätverk för produktion i stället.
- Ange värdet för Databassortering (under Ytterligare inställningar) till Latin1_General_100_BIN2_UTF8.

Konfigurera identitetsbaserad autentisering

Hanterade identiteter gör din app säkrare genom att eliminera hemligheter från din app, till exempel autentiseringsuppgifter i anslutningssträngarna. Du kan välja mellan systemtilldelad och användartilldelad hanterad identitet, men användartilldelad hanterad identitet rekommenderas eftersom den inte är kopplad till appens livscykel.

I det här avsnittet konfigurerar du användartilldelad hanterad identitet för Azure Storage.

Ange miljövariablerna.

subscription=<SUBSCRIPTION_ID>
identity=<IDENTITY_NAME>

Skapa en hanterad identitetsresurs.

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

Tilldela användaridentiteten till containerappen.

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

Ange omfånget för behörigheterna för rollbaserad åtkomstkontroll (RBAC).

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

Hämta användaridentitetens clientId.

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

Tilldela rollen Lagringsblobdataägare för åtkomst till lagringskontot.

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

Konfigurera appinställningar

Anmärkning

Autentisering till MSSQL-databasen med hanterad identitet stöds inte när du är värd för en Durable Functions-app i Azure Container Apps. För tillfället autentiseras denna guide med hjälp av anslutningssträngar.

Från SQL-databasresursen i Azure-portalen går du till Inställningar>Anslutningssträngar för att hitta anslutningssträngen.

Skärmdump av Azure SQL-databasens anslutningssträng i Azure-portalen.

Anslutningssträngen bör ha ett format som liknar:

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

Om du glömmer lösenordet från föregående steg för att skapa databasen kan du återställa det på SQL Server-resursen.

Skärmbild av knappen återställ lösenord på sidan Azure SQL serverresurs.

Lagra SQL-databasens anslutningssträng som en hemlighet med namnet sqldbconnection i containerappen.

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

Lägg till följande inställningar i appen:

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

Testa den distribuerade Durable Functions-appen

Använd ett HTTP-testverktyg för att skicka en POST begäran till HTTP-utlösarslutpunkten, som bör likna:
```
https://<APP NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io/api/DurableFunctionsOrchestrationCSharp1_HttpStart
```
Svaret är HTTP-funktionens inledande resultat som meddelar dig att Durable Functions-orkestreringen har startats framgångsrikt. Även om svaret innehåller några användbara URL:er visas inte orkestreringens slutresultat ännu.
Kopiera/klistra in URL-värdet för statusQueryGetUri i webbläsarens adressfält och kör. Du kan också fortsätta att använda HTTP-testverktyget för att utfärda GET begäran.

Begäran frågar orkestreringsinstansen om statusen. Du bör se att instansen är klar och utdata eller resultat från Durable Functions-appen.
```
{
    "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"
}
```

Nästa steg

Azure Container Apps värd för Azure Functions
MSSQL-lagringsproviderns arkitektur, konfiguration och arbetsbelastningsbeteende
Durable Task Scheduler – den rekommenderade Azure-hanterade bakdelen för nya hållbara arbetsflöden
Översikt över Durable Functions

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-28