Ospita un'app di Durable Functions con il back-end MSSQL in App contenitore di Azure (.NET isolato)

App contenitore di Azure è l'unica opzione di hosting che supporta la scalabilità automatica guidata dagli eventi (scalabilità a zero) per Durable Functions quando si usa il provider di archiviazione Microsoft SQL (MSSQL. Se si usa un back-end di archiviazione diverso, è necessario impostare il numero minimo di repliche su maggiore di zero.

Suggerimento

Per i nuovi progetti, è consigliabile usare l'Utilità di pianificazione Durable, che è il back-end gestito Azure consigliato per i flussi di lavoro durevoli. Questa guida illustra in modo specifico il back-end MSSQL.

Per altre informazioni sull'esecuzione di Funzioni di Azure nelle App per container, vedere App contenitore di Azure hosting di Funzioni di Azure.

In questo articolo vengono illustrate le operazioni seguenti:

Creare un'immagine Docker da un progetto Durable Functions locale.
Creare un Azure Container App e le risorse correlate.
Distribuire l'immagine nell'app Azure Container e configurare l'autenticazione.

Prerequisiti

Visual Studio Code installato.
.NET 8.0 SDK.
Docker e ID Docker
Interfaccia della riga di comando di Azure versione 2.47 o successiva.
Strumenti di base di Funzioni di Azure
Account Azure con una sottoscrizione attiva. Creare un account gratuito.
Strumento di test HTTP che protegge i dati. Per altre informazioni, vedere strumenti di test HTTP.

Creare un progetto Durable Functions locale

Questa guida presuppone che sia presente un progetto .NET isolato Durable Functions configurato con il back-end MSSQL. Se non ne è ancora disponibile uno, seguire la guida introduttiva di MSSQL per creare e testarne una in locale, quindi tornare qui.

Prima di procedere, verificare che:

Il progetto è mirato a .NET 8.0 con il modello di worker isolato
Il provider di archiviazione MSSQL è configurato in host.json
L'app viene eseguita correttamente con func start

Creare un Dockerfile nella radice del progetto che descrive l'ambiente minimo necessario per eseguire l'app per le funzioni in un contenitore.

Nella directory radice del progetto creare un nuovo file denominato Dockerfile.

Copiare/incollare il contenuto seguente nel 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"]

Salva il file.
Aggiungere un file con estensione dockerignore con il contenuto seguente:
```
local.settings.json
```
Salva il file .dockerignore.

Compilare l'immagine del contenitore

Compilare l'immagine Docker. Trova l'elenco completo delle immagini di base supportate per le Funzioni Azure di Microsoft in Funzioni di Azure Base | Docker Hub

Avviare il daemon Docker.
Accedere a Docker con il docker login comando .
Quando richiesto, accedere con il nome utente e la password. Un messaggio "Accesso Riuscito" conferma che è stato eseguito l'accesso.
Passare alla directory radice del progetto.
Eseguire il comando seguente per compilare l'immagine, sostituendo <DOCKER_ID> con l'ID dell'account Docker Hub:
```
dockerId=<DOCKER_ID>
imageName=<IMAGE_NAME>
imageVersion=v1.0.0

docker build --tag $dockerId/$imageName:$imageVersion .
```
Annotazioni

Se stai utilizzando un computer Mac serie M, usa --platform linux/amd64 invece.
Eseguire il push dell'immagine in Docker:
```
docker push $dockerId/$imageName:$imageVersion
```
A seconda della velocità di rete, il push iniziale dell'immagine potrebbe richiedere alcuni minuti. Durante l'attesa, passare alla sezione successiva.

Creare risorse di Azure per Durable Functions su Container Apps

Creare le risorse di Azure necessarie per l'esecuzione di Durable Functions in un'app contenitore.

Gruppo di risorse di Azure: Gruppo di risorse contenente tutte le risorse create.
Ambiente dell'app Azure Container: Ambiente che ospita l'app contenitore.
App contenitore di Azure: l'immagine contenente l'app Funzioni Durable viene distribuita in questa app.
Account di archiviazione di Azure: Richiesto dall'app per le funzioni per archiviare i dati correlati all'app, ad esempio il codice dell'applicazione.

Impostazione iniziale

In un nuovo terminale accedere alla sottoscrizione di Azure:
```
az login  

az account set -s <subscription_name>
```

Eseguire i comandi necessari per configurare l'estensione CLI di App contenitore di Azure.

az upgrade

az extension add --name containerapp --upgrade

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

Un profilo del carico di lavoro determina la quantità di risorse di calcolo e memoria disponibili per le app contenitore distribuite in un ambiente. Creare un profilo di carico di lavoro a consumo per il supporto con scalabilità zero e il pagamento in base all'uso.

Impostare le variabili di ambiente.

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

Crea un gruppo di risorse.

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

Creare l'ambiente app contenitore.

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

Creare un'applicazione container basata sull'immagine di Durable Functions.

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

Prendere nota dell'URL dell'app, che dovrebbe essere simile a https://<APP_NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io.

Creare basi di dati

Creare un account di archiviazione di Azure, richiesto dall'app per le funzioni.

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

Nel portale di Azure creare un database SQL di Azure per rendere persistenti le informazioni sullo stato. Durante la creazione:
- Abilitare i servizi e le risorse di Azure per accedere a questo server (in Networking). Per la produzione, usare invece restrizioni firewall più avanzate o configurazioni di rete virtuale .
- Impostare il valore per Le regole di confronto del database (in Impostazioni aggiuntive) su Latin1_General_100_BIN2_UTF8.

Configurare l'autenticazione basata su identità

Le identità gestite rendono l'app più sicura eliminando i segreti dall'app, ad esempio le credenziali nelle stringhe di connessione. Sebbene sia possibile scegliere tra l'identità gestita assegnata dal sistema e l'identità gestita assegnata dall'utente, si consiglia l'identità gestita assegnata dall'utente, poiché non è legata al ciclo di vita dell'app.

In questa sezione viene configurata l'identità gestita assegnata dall'utente per Archiviazione di Azure.

Impostare le variabili di ambiente.

subscription=<SUBSCRIPTION_ID>
identity=<IDENTITY_NAME>

Creare una risorsa di identità gestita.

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

Assegnare l'identità utente all'app contenitore.

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

Impostare l'ambito delle autorizzazioni di controllo degli accessi in base al ruolo.

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

Ottenere clientId dell'identità utente.

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

Assegnare il ruolo Proprietario dati BLOB di archiviazione per l'accesso all'account di archiviazione.

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

Configurare le impostazioni dell'app

Annotazioni

L'autenticazione nel database MSSQL tramite l'identità gestita non è supportata quando si ospita un'app Durable Functions nelle app contenitore di Azure. Per il momento, questa guida esegue l'autenticazione usando le stringhe di connessione.

Dalla risorsa del database SQL nel portale di Azure passare a Impostazioni>Stringhe di connessione per trovare la stringa di connessione.

Screenshot della stringa di connessione del database Azure SQL nel portale di Azure.

La stringa di connessione deve avere un formato simile al seguente:

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

Se si dimentica la password dal passaggio di creazione del database precedente, è possibile reimpostarla nella risorsa di SQL Server.

Screenshot del pulsante per reimpostare la password nella pagina risorsa del server Azure SQL.

Archiviare la stringa di connessione del database SQL come segreto denominato sqldbconnection nell'app contenitore.

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

Aggiungere le impostazioni seguenti all'app:

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

Testare l'app Durable Functions distribuita

Usare uno strumento di test HTTP per inviare una POST richiesta all'endpoint del trigger HTTP, che dovrebbe essere simile a:
```
https://<APP NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io/api/DurableFunctionsOrchestrationCSharp1_HttpStart
```
La risposta è il risultato iniziale della funzione HTTP che informa che l'orchestrazione di Durable Functions è stata avviata correttamente. Anche se la risposta include alcuni URL utili, non visualizza ancora il risultato finale dell'orchestrazione.
Copiare/incollare il valore url per statusQueryGetUri nella barra degli indirizzi del browser ed eseguire. In alternativa, è possibile continuare a usare lo strumento di test HTTP per inviare la GET richiesta.

La richiesta esegue una query per determinare lo stato dell'istanza di orchestrazione. Si noterà che l'istanza è stata completata e gli output o i risultati dell'app 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"
}
```

Passaggi successivi

App contenitore di Azure hosting di Funzioni di Azure
Architettura, configurazione e comportamento del carico di lavoro del provider di archiviazione MSSQL
Scheduler di Attività Durevoli: il back-end gestito da Azure consigliato per nuovi progetti di workflow durevoli
Introduzione a Durable Functions

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-28