Snabbstart: Skapa en Durable Functions-app som använder MSSQL-lagringsprovidern

Använd Durable Functions, en funktion i Azure Functions, för att skriva tillståndskänsliga funktioner i en serverlös miljö. Durable Functions hanterar tillstånd, kontrollpunkter och omstarter i ditt program.

Durable Functions stöder flera lagringsleverantörer, även kallade backend-komponenter, för lagring av orkestrerings- och entitetens körningstillstånd. I den här snabbstarten skapar du en Durable Functions-app för att använda Microsoft SQL Server-lagringsprovidern (MSSQL) med hjälp av Visual Studio Code.

Den här snabbstarten skapar en .NET-app (isolerad modell) i demonstrationssyfte. Innehållet i den här artikeln gäller för andra språk på liknande sätt.

Förutsättningar

För att slutföra den här snabbstarten behöver du:

• Visual Studio Code installerat.

• Azure Functions Visual Studio Code-tillägget har installerats.

• Den senaste versionen av Azure Functions Core Tools installerad.

• .NET 8.0 SDK installerat.

• Docker installerat.

• En prenumeration för Azure.

• Ett HTTP-testverktyg som skyddar dina data. Mer information finns i HTTP-testverktyg.

Skapa ett Azure Functions-projekt

Skapa ett lokalt Azure Functions-projekt i Visual Studio Code.

1. På menyn Visa väljer du Kommandopalett (eller ctrl+Skift+P).

2. I kommandotolken (>) anger du och väljer sedan Azure Functions: Create New Project (Skapa nytt projekt).

   

3. Välj Bläddra. I dialogrutan Välj mapp går du till en mapp som ska användas för projektet och väljer sedan Välj.

4. I anvisningarna väljer eller anger du följande värden:

   Omedelbar	Åtgärd	Beskrivning
   Välj ett språk för funktionsappprojektet	Välj .NET	Skapar ett lokalt C#Functions-projekt
   Välj en .NET-körning	Välj .NET 8.0 isolerad.	Skapar ett Functions-projekt som stöder .NET 8 som körs i en isolerad arbetsprocess och Azure Functions Runtime 4.0.
   Välj en mall för projektets första funktion	Välj Durable Functions Orchestration.	Skapar en Durable Functions-orkestrering.
   Välj en beständig lagringstyp	Välj MSSQL.	Väljer MSSQL-lagringsprovidern.
   Ange ett funktionsnamn	Ange HelloOrchestration.	Ett namn för orkestreringsfunktionen.
   Ange ett namnområde	Ange Company.Function.	Ett namnområde för den genererade klassen.
   Välj hur du vill öppna projektet	Välj Öppna i aktuellt fönster.	Öppnar Visual Studio Code i den mapp som du har valt.

Visual Studio Code installerar Azure Functions Core Tools om det krävs för att skapa projektet. Det skapar också ett funktionsappprojekt i en mapp. Det här projektet innehåller konfigurationsfilerna host.json och local.settings.json .

En annan fil, HelloOrchestration.cs, innehåller de grundläggande byggstenarna i en Durable Functions-app:

Mer information om dessa funktioner finns i Typer och funktioner för Durable Functions.

Konfigurera databasen

Eftersom MSSQL-serverdelen är utformad för portabilitet har du flera alternativ för att konfigurera säkerhetskopieringsdatabasen. Du kan till exempel konfigurera en lokal SQL Server-instans, använda en fullständigt hanterad instans av Azure SQL Database eller använda andra SQL Server-kompatibla värdalternativ.

Du kan också utföra lokal offlineutveckling med HJÄLP av SQL Server Express på din lokala Windows-dator eller använda en SQL Server Docker-avbildning som körs i en Docker-container.

Den här snabbstarten fokuserar på att använda en SQL Server Docker-avbildning.

Konfigurera din lokala Docker-baserade SQL Server-instans

Använd följande PowerShell-kommandon för att konfigurera en lokal SQL Server-databas i Docker. Du kan installera PowerShell på Windows, macOS eller Linux.

# primary parameters
$pw        = "yourStrong(!)Password"
$edition   = "Developer"
$port      = 1433
$tag       = "2019-latest"
$dbname    = "DurableDB"
$collation = "Latin1_General_100_BIN2_UTF8"

# pull the image from the Microsoft container registry
docker pull mcr.microsoft.com/mssql/server:$tag

# run the image and provide some basic setup parameters
docker run --name mssql-server -e 'ACCEPT_EULA=Y' -e "MSSQL_SA_PASSWORD=$pw" -e "MSSQL_PID=$edition" -p ${port}:1433 -d mcr.microsoft.com/mssql/server:$tag

# wait a few seconds for the container to start...

# create the database with strict binary collation
docker exec -it mssql-server /opt/mssql-tools/bin/sqlcmd -S . -U sa -P "$pw" -Q "CREATE DATABASE [$dbname] COLLATE $collation"

# if sqlcmd is in the mssql-tools18 folder
# docker exec -it mssql-server /opt/mssql-tools18/bin/sqlcmd -C -S . -U sa -P "$pw" -Q "CREATE DATABASE [$dbname] COLLATE $collation"

Nu bör du ha en lokal SQL Server som körs på Docker och lyssnar på porten 1443. Om porten 1443 står i konflikt med en annan tjänst kör du dessa kommandon igen när du har ändrat variabeln $port till ett annat värde.

Kontrollera databasinstallationen genom att utföra en sökning i din nya SQL-databas.

docker exec -it mssql-server /opt/mssql-tools/bin/sqlcmd -S . -U sa -P "$pw" -Q "SELECT name FROM sys.databases"

Om databaskonfigurationen har slutförts visas namnet på databasen (till exempel DurableDB) i kommandoradsutdata:

name

--------------------------------------------------------------
master

tempdb

model

msdb

DurableDB

Felsökning

Om du stöter på "Felsvar från daemon: OCI runtime exec failed" när du kör docker exec för att skapa databasen, är det troligt att mappen /opt/mssql-tools/bin/sqlcmd inte finns. Öppna Docker Desktop, välj din SQL Server Docker-container, välj Filer och bläddra efter mappen mssql-tools. Kontrollera om den här mappen har ett annat namn, till exempel /opt/mssql-tools18/bin/sqlcmd. Uppdatera kommandot i enlighet med detta.

I ODBC Driver 18 för SQL Server är alternativet Kryptera anslutning inställt på true som standard. Om du stöter på "error:1416F086:SSL-rutiner:tls_process_server_certificate:certificate verify failed:self signed certificate" när du kör docker exec för att utföra databasåtgärder, lägg till -C, vilket motsvarar alternativet TRUSTSERVERCERTIFICATE = true ADO.net.

Lägg till SQL-anslutningssträng i local.settings.json

MSSQL-serverdelen behöver en anslutningssträng för att komma åt databasen. Hur du hämtar en anslutningssträng beror främst på din specifika MSSQL-serverprovider.

Om du använder föregående Docker-kommandon utan att ändra några parametrar är din anslutningssträng:

Server=localhost,1433;Database=DurableDB;User Id=sa;Password=yourStrong(!)Password;

I local.settings.jsontilldelar du anslutningssträngen för den Docker-baserade SQL Server-instansen till SQLDB_Connection. Den här variabeln lades till av Visual Studio Code när du valde MSSQL som serverdel för din Durable Functions-app:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true", 
    "SQLDB_Connection": "Server=localhost,1433;Database=DurableDB;User Id=sa;Password=yourStrong(!)Password;",
    "FUNCTIONS_WORKER_RUNTIME": "<dependent on your programming language>"
  }
}

Testa lokalt

Öppna ett terminalfönster i appens rotmapp och kör azurite start. Azurite är Azure Storage-emulatorn, som behövs för att köra en funktionsapp.

Öppna ett annat terminalfönster i appens rotmapp och starta funktionsappen genom att köra func host start.

1. I terminalfönstret kopierar du URL-slutpunkten för din HTTP-utlösta funktion.

   

2. Använd ett HTTP-testverktyg för att skicka en HTTP POST-begäran till URL-slutpunkten.

   Svaret är HTTP-funktionens första resultat. Det meddelar dig att Durable Functions-orkestreringen har startat framgångsrikt. Det visar ännu inte slutresultatet av orkestreringen. Svaret innehåller några användbara URL:er.

3. Kopiera URL-värdet för statusQueryGetUri, klistra in det i webbläsarens adressfält och kör begäran. 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 har slutförts och att den innehåller utdata eller resultat från Durable Functions-appen som i det här exemplet:

   {
       "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"
   }
   

Kör din app i Azure

Om du vill köra din app i Azure måste du skapa olika resurser. Skapa alla resurser i samma resursgrupp för att få en praktisk rensning senare.

Skapa en Azure SQL-databas

I Azure Portal kan du skapa en Azure SQL-databas. När du skapar:

• Aktivera Azure-tjänster och -resurser för åtkomst till den här servern (under Nätverk)
• Ange värdet för Databassortering (under Ytterligare inställningar) till Latin1_General_100_BIN2_UTF8.

Skapa en Azure Functions-app och stödresurser

1. Öppna ett terminalfönster och logga in på Azure:

   az login
   

2. Skapa följande resurser i samma resursgrupp och region som din SQL-databas:

   • Ett allmänt lagringskonto som används för att lagra viktiga appdata, till exempel själva programkoden. Lagringskontonamn måste innehålla tre till 24 tecken och får endast bestå av siffror och små bokstäver.
   • En plan för premiumfunktionsappar
   • En funktionsapp

   # Variables
   location=<REGION>
   resourceGroup=<RESOURCE_GROUP_NAME>
   storage=<STORAGE_NAME>
   planName=<PREMIUM_PLAN_NAME>
   functionApp=<APP_NAME>
   skuStorage="Standard_LRS"
   skuPlan="EP1"
   functionsVersion="4"
   
   # Create an Azure storage account
   echo "Creating $storage"
   az storage account create --name $storage --location "$location" --resource-group $resourceGroup --sku $skuStorage --allow-blob-public-access false
   
   # Create a premium plan
   echo "Creating $premiumPlan"
   az functionapp plan create --name $planName --resource-group $resourceGroup --location "$location" --sku $skuPlan
   
   # Create a function app hosted in the premium plan
   echo "Creating $functionApp"
   az functionapp create --name $functionApp --storage-account $storage --plan $planName --resource-group $resourceGroup --functions-version $functionsVersion
   

Skapa en hanterad Azure-identitet

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. Den här snabbstarten visar hur du konfigurerar användartilldelad hanterad identitet, vilket är det rekommenderade alternativet eftersom det inte är kopplat till appens livscykel.

Följande kommandon skapar identitetsresursen och tilldelar den till appen:

# Variables
subscription=<SUBSCRIPTION_ID>
identity=<IDENTITY_NAME>

# Create a managed identity resource
echo "Creating $identity"
az identity create -g $resourceGroup -n $identity --location "$location"

# Construct the identity resource ID 
resourceId="/subscriptions/$subscription/resourceGroups/$resourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$identity"

# Assign the identity to the Azure Functions app
echo "Assigning $identity to app"
az functionapp identity assign -g $resourceGroup -n $functionApp --identities "$resourceId"

# Get the identity's ClientId and PrincipalId (also called ObjectId) for a later step. 
clientId=$(az identity show --name $identity --resource-group $resourceGroup --query 'clientId' --output tsv)

principalId=$(az identity show --name $identity --resource-group $resourceGroup --query 'principalId' --output tsv)

Bevilja åtkomst till Azure Storage och Azure SQL Database

Azure Storage

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

# Set the scope of the access
scope="/subscriptions/$subscription/resourceGroups/$resourceGroup/providers/Microsoft.Storage/storageAccounts/$storage"

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

Azure SQL Database

1. Börja med att ange utvecklaridentiteten som databasens administratör.

   Den tilldelade är din identitet, så ändra till din e-post:

   assignee=$(az ad user show --id "someone@example.com" --query "id" --output tsv)
   

   Ange tilldelad som administratör för Azure SQL-databasen:

   az sql server ad-admin create --resource-group $resourceGroup --server-name <SQL_SERVER_NAME> --display-name ADMIN --object-id "$assignee"
   

2. Anslut till DEN SQL-databas som skapades tidigare med hjälp av verktyg som Azure Data Studio eller SQL Management Server Studio. Eller så kan du köra följande SQLCMD-kommando för att ansluta:

   sqlcmd -S <SQL_SERVER_NAME>.database.windows.net -d <DATABASE_NAME> -U <someone@example.com> -P "ACCOUNT_PASSWORD" -G -l 30
   

   Ge din identitet db_owner åtkomst genom att köra följande fråga mot databasen. IDENTITY_OBJECT_ID är PrincipalId från steget för att skapa identitet.

   CREATE USER "<IDENTITY_NAME>" FROM EXTERNAL PROVIDER With OBJECT_ID='<IDENTITY_OBJECT_ID>'
   ALTER ROLE db_owner ADD MEMBER "<IDENTITY_NAME>";
   GO
   

3. Anslut till master databasen och ge din identitet dbmanager åtkomst:

   CREATE USER "<IDENTITY_NAME>" FROM EXTERNAL PROVIDER With OBJECT_ID='<IDENTITY_OBJECT_ID>'
   ALTER ROLE dbmanager ADD MEMBER "<IDENTITY_NAME>";
   GO
   

Ange nödvändiga appinställningar

Du måste lägga till följande appinställningar i din app:

• AzureWebJobsStorage__accountName: Namn på Azure Storage-konto
• AzureWebJobsStorage__clientId: ClientId för den hanterade identiteten
• AzureWebJobsStorage__credential: Typ av autentiseringsuppgifter, som är hanterad identitet
• SQLDB_Connection: SQL Database-anslutningssträng

Om du använder användartilldelad hanterad identitet för att autentisera till SQL-databasen bör anslutningssträngen se ut så här:

dbserver=<SQL_SERVER_NAME>
sqlDB=<SQL_DB_NAME>
clientId=<IDENTITY_CLIENT_ID>

sqlconnstr="Server=tcp:$dbserver.database.windows.net,1433;Initial Catalog=$sqlDB;Persist Security Info=False;User ID=$clientId;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Authentication='Active Directory Managed Identity';"

För Flex Consumption-appar använder du en anslutningssträng för att autentisera för tillfället. Du hittar den genom att gå till SQL-databasresursen på Azure-portalen, navigera till fliken Inställningar och sedan klicka på Anslutningssträngar:

Anslutningssträngen bör ha följande format:

dbserver=<SQL_SERVER_NAME>
sqlDB=<SQL_DB_NAME>
username=<DB_USER_LOGIN>
password=<DB_USER_PASSWORD>

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

Kör följande kommando för att ange inställningarna:

az functionapp config appsettings set --name $functionApp --resource-group $resourceGroup --settings AzureWebJobsStorage__accountName="$storage" AzureWebJobsStorage__clientId="$clientId" AzureWebJobsStorage__credential="managedidentity" SQLDB_Connection=$sqlconnstr

Ta bort den befintliga AzureWebJobsStorage inställningen:

az functionapp config appsettings delete --name $functionApp --resource-group $resourceGroup --setting-names "AzureWebJobsStorage"

Distribuera det lokala projektet till Azure och testa

Slutligen distribuerar du appen till Azure i rotprojektmappen genom att köra:

func azure functionapp publish $functionApp

När distributionen är klar kör du följande för att hämta HTTP-utlösarens URL:

az functionapp function list --resource-group $resourceGroup --name $functionApp  --query '[].{Function:name, URL:invokeUrlTemplate}' --output json

Testa precis som du gjorde under den lokala utvecklingen med ett HTTP-testverktyg.

Du kan också kontrollera att MSSQL-serverdelen är korrekt konfigurerad genom att fråga databasen efter uppgiftshubbens data.

Du kan till exempel fråga orkestreringsinstanserna i sql-databasens översiktsfönster. Välj Power Query-redigeraren, autentisera och kör sedan följande fråga:

SELECT TOP 5 InstanceID, RuntimeStatus, CreatedTime, CompletedTime FROM dt.Instances

När du har kört en enkel orkestrering bör du se minst ett resultat, som du ser i det här exemplet:

Nästa steg

• Vara värd för en Durable Functions-app med MSSQL-serverdelen i Azure Container Apps.
• Mer information om den här serverdelens arkitektur, konfiguration och arbetsbelastning finns i dokumentationen för MSSQL-lagringsprovidern .