Automatizzare la distribuzione di risorse per l'app per le funzioni in Funzioni di Azure

  • Articolo

È possibile usare un file Bicep o un modello di Azure Resource Manager per automatizzare il processo di distribuzione di un'app per le funzioni in risorse di Azure nuove o esistenti. Tale automazione offre un ottimo modo per integrare le distribuzioni di risorse con il codice sorgente in DevOps, ripristinare un'app per le funzioni e le risorse correlate da un backup o distribuire più volte una topologia di app.

Questo articolo illustra come automatizzare la creazione di risorse e distribuzione per Funzioni di Azure. A seconda dei trigger e delle associazioni usate dalle funzioni, potrebbe essere necessario distribuire altre risorse, che non rientra nell'ambito di questo articolo.

Il codice modello specifico dipende dalla modalità di hosting dell'app per le funzioni, dalla distribuzione di codice o da un'app per le funzioni in contenitori e dal sistema operativo usato dall'app. Questo articolo supporta le opzioni di hosting seguenti:

Opzione Hosting Tipo di distribuzione Per altre informazioni, vedere...
Piano di consumo di Funzioni di Azure Solo codice Piano a consumo
Funzioni di Azure piano Elastic Premium Codice | Contenitore Piano Premium
piano dedicato Funzioni di Azure (servizio app) Codice | Contenitore Piano dedicato
App contenitore di Azure Solo contenitore Hosting di app contenitore di Funzioni di Azure
Azure Arc Codice | Contenitore servizio app, funzioni e app per la logica in Azure Arc (anteprima)

Risorse necessarie

Una distribuzione ospitata Funzioni di Azure è in genere costituita da queste risorse:

Conto risorse Requisito Informazioni di riferimento su sintassi e proprietà
Un account di archiviazione Richiesto Microsoft.Storage/storageAccounts
Un componente di Application Insights Consigliato Microsoft.Insights/components
Un piano di hosting Obbligatorio1 Microsoft.Web/serverfarms
Un'app per le funzioni Richiesto Microsoft.Web/sites

Una distribuzione Funzioni di Azure per un piano a consumo è in genere costituita da queste risorse:

Conto risorse Requisito Informazioni di riferimento su sintassi e proprietà
Un account di archiviazione Richiesto Microsoft.Storage/storageAccounts
Un componente di Application Insights Consigliato Microsoft.Insights/components
Un'app per le funzioni Richiesto Microsoft.Web/sites

Una distribuzione ospitata in App Contenitore di Azure è in genere costituita da queste risorse:

Conto risorse Requisito Informazioni di riferimento su sintassi e proprietà
Un account di archiviazione Richiesto Microsoft.Storage/storageAccounts
Un componente di Application Insights Consigliato Microsoft.Insights/components
Un ambiente gestito Richiesto Microsoft.App/managedEnvironments
Un'app per le funzioni Richiesto Microsoft.Web/sites

Una distribuzione ospitata in Azure Arc è in genere costituita da queste risorse:

Conto risorse Requisito Informazioni di riferimento su sintassi e proprietà
Un account di archiviazione Richiesto Microsoft.Storage/storageAccounts
Un componente di Application Insights Consigliato Microsoft.Insights/components
Un ambiente Kubernetes servizio app Richiesto Microsoft.ExtendedLocation/customLocations
Un'app per le funzioni Richiesto Microsoft.Web/sites

1Un piano di hosting esplicito non è necessario quando si sceglie di ospitare l'app per le funzioni in un piano a consumo.

Quando si distribuiscono più risorse in un singolo file Bicep o modello di Resource Manager, l'ordine in cui vengono create le risorse è importante. Questo requisito è il risultato delle dipendenze tra le risorse. Per tali dipendenze, assicurarsi di usare l'elemento dependsOn per definire la dipendenza nella risorsa dipendente. Per altre informazioni, vedere Definire l'ordine di distribuzione delle risorse nei modelli arm o nelle dipendenze delle risorse in Bicep.

Questo articolo presuppone che si abbia una conoscenza di base sulla creazione di file Bicep o sulla creazione di modelli di Azure Resource Manager e che gli esempi vengano visualizzati come singole sezioni per risorse specifiche. Per un ampio set di esempi completi di file Bicep e modelli di Resource Manager, vedere questi esempi di distribuzione di app per le funzioni.

Prerequisiti

Questo articolo presuppone che sia già stato creato un ambiente gestito in App Azure Container. È necessario sia il nome che l'ID dell'ambiente gestito per creare un'app per le funzioni ospitata in App contenitore.

Questo articolo presuppone che sia già stata creata una posizione personalizzata abilitata per servizio app in un cluster Kubernetes abilitato per Azure Arc. Sono necessari sia l'ID percorso personalizzato che l'ID ambiente Kubernetes per creare un'app per le funzioni ospitata in una posizione personalizzata di Azure Arc.

Creare un account di archiviazione

Tutte le app per le funzioni richiedono un account di archiviazione di Azure. È necessario un account per utilizzo generico che supporti BLOB, tabelle, code e i file. Per altre informazioni, vedere i requisiti dell'account di archiviazione per Funzioni di Azure.

Importante

L'account di archiviazione viene usato per archiviare dati importanti dell'app, a volte incluso il codice dell'applicazione stesso. È consigliabile limitare l'accesso da altre app e utenti all'account di archiviazione.

Questa sezione di esempio crea un account di archiviazione per utilizzo generico v2 Standard:

"resources": [
  {
    "type": "Microsoft.Storage/storageAccounts",
    "apiVersion": "2022-05-01",
    "name": "[parameters('storageAccountName')]",
    "location": "[parameters('location')]",
    "kind": "StorageV2",
    "sku": {
      "name": "[parameters('storageAccountType')]"
    },
    "properties": {
      "supportsHttpsTrafficOnly": true,
      "defaultToOAuthAuthentication": true
    }
  }
]

Per altre informazioni di contesto, vedere il file di azuredeploy.json completo nel repository dei modelli.

È necessario impostare la stringa di connessione di questo account di archiviazione come impostazione dell'appAzureWebJobsStorage, che funzioni richiede. I modelli in questo articolo costruiscono questo valore stringa di connessione in base all'account di archiviazione creato, una procedura consigliata. Per altre informazioni, vedere Configurazione dell'applicazione.

Abilitare i log di archiviazione

Poiché l'account di archiviazione viene usato per i dati importanti dell'app per le funzioni, è necessario monitorare l'account per la modifica del contenuto. Per monitorare l'account di archiviazione, è necessario configurare i log delle risorse di Monitoraggio di Azure per Archiviazione di Azure. In questa sezione di esempio viene usata un'area di lavoro Log Analytics denominata myLogAnalytics come destinazione per questi log.

"resources": [
  {
    "type": "Microsoft.Insights/diagnosticSettings",
    "apiVersion": "2021-05-01-preview",
    "scope": "[format('Microsoft.Storage/storageAccounts/{0}/blobServices/default', parameters('storageAccountName'))]",
    "name": "[parameters('storageDataPlaneLogsName')]",
    "properties": {
        "workspaceId": "[resourceId('Microsoft.OperationalInsights/workspaces', parameters('myLogAnalytics'))]",
        "logs": [
          {
            "category": "StorageWrite",
            "enabled": true
          }
        ],
        "metrics": [
          {
            "category": "Transaction",
            "enabled": true
          }
        ]
    }
  }
]

Questa stessa area di lavoro può essere usata per la risorsa di Application Insights definita in un secondo momento. Per altre informazioni, tra cui come usare questi log, vedere Monitoraggio Archiviazione di Azure.

Creare Application Insights

Application Insights è consigliato per monitorare le esecuzioni delle app per le funzioni. In questa sezione di esempio la risorsa di Application Insights viene definita con il tipo Microsoft.Insights/components e il tipo web:

{
  "type": "Microsoft.Insights/components",
  "apiVersion": "2020-02-02",
  "name": "[variables('applicationInsightsName')]",
  "location": "[parameters('appInsightsLocation')]",
  "tags": {
    "[format('hidden-link:{0}', resourceId('Microsoft.Web/sites', parameters('functionAppName')))]": "Resource"
  },
  "properties": {
    "Application_Type": "web"
  },
  "kind": "web"
},

Per altre informazioni di contesto, vedere il file di azuredeploy.json completo nel repository dei modelli.

La connessione deve essere fornita all'app per le funzioni usando l'impostazione dell'applicazione APPLICATIONINSIGHTS_CONNECTION_STRING . Per altre informazioni, vedere Impostazioni dell'applicazione.

Gli esempi in questo articolo ottengono il valore stringa di connessione per l'istanza creata. Le versioni precedenti potrebbero invece usare APPINSIGHTS_INSTRUMENTATIONKEY per impostare la chiave di strumentazione, che non è più consigliata.

Creare il piano di hosting

Le app ospitate in un piano Funzioni di Azure Premium o dedicato (servizio app) devono avere il piano di hosting definito in modo esplicito.

Il piano Premium offre la stessa scalabilità del piano a consumo, ma include risorse dedicate e funzionalità aggiuntive. Per altre informazioni, vedere Funzioni di Azure Piano Premium.

Un piano Premium è un tipo speciale di serverfarm risorsa. È possibile specificarlo usando EP1, EP2o EP3 per il valore della Name proprietà nella sku proprietà . Il modo in cui si definisce il piano di hosting di Funzioni dipende dal fatto che l'app per le funzioni venga eseguita in Windows o in Linux. Questa sezione di esempio crea un EP1 piano:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "name": "EP1",
      "tier": "ElasticPremium",
      "family": "EP"
    },
    "kind": "elastic",
    "properties": {
      "maximumElasticWorkerCount": 20
    }
  }
]

Per altre informazioni di contesto, vedere il file di azuredeploy.json completo nel repository dei modelli.

Per altre informazioni sull'oggetto sku , vedere SkuDefinition o esaminare i modelli di esempio.

Nel piano Dedicato (servizio app) l'app per le funzioni viene eseguita in macchine virtuali dedicate in SKU Basic, Standard e Premium nei piani servizio app, simili alle app Web. Per altre informazioni, vedere Piano dedicato.

Per un esempio di file Bicep/modello di Azure Resource Manager, vedere App per le funzioni in app Azure piano di servizio

In Funzioni il piano dedicato è solo un piano servizio app regolare, definito da una serverfarm risorsa. È necessario specificare almeno il name valore. Per un elenco dei nomi dei piani supportati, vedere l'impostazione in az appservice plan create per l'elenco --sku corrente dei valori supportati per un piano dedicato.

Il modo in cui si definisce il piano di hosting dipende dal fatto che l'app per le funzioni venga eseguita in Windows o in Linux:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "tier": "Standard",
      "name": "S1",
      "size": "S1",
      "family": "S",
      "capacity": 1
    }
  }
]

Per altre informazioni di contesto, vedere il file di azuredeploy.json completo nel repository dei modelli.

Creare il piano di hosting

Non è necessario definire in modo esplicito una risorsa del piano di hosting a consumo. Quando si ignora questa definizione di risorsa, un piano viene creato o selezionato automaticamente per ogni area quando si crea la risorsa dell'app per le funzioni stessa.

È possibile definire in modo esplicito un piano a consumo come tipo speciale di serverfarm risorsa, che si specifica usando il valore Dynamic per le computeMode proprietà e sku . Questa sezione di esempio illustra come definire in modo esplicito un piano a consumo. Il modo in cui si definisce un piano di hosting dipende dal fatto che l'app per le funzioni venga eseguita in Windows o in Linux.

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "name": "Y1",
      "tier": "Dynamic",
      "size": "Y1",
      "family": "Y",
      "capacity": 0
    },
    "properties": {
      "computeMode": "Dynamic"
    }
  }
]

Per altre informazioni di contesto, vedere il file di azuredeploy.json completo nel repository dei modelli.

Ambiente Kubernetes

Funzioni di Azure possono essere distribuiti in Kubernetes abilitato per Azure Arc come progetto di codice o app per le funzioni in contenitori.

Per creare l'app e pianificare le risorse, è necessario aver già creato un ambiente Kubernetes servizio app per un cluster Kubernetes abilitato per Azure Arc. Gli esempi in questo articolo presuppongono di avere l'ID risorsa della posizione personalizzata (customLocationId) e servizio app ambiente Kubernetes (kubeEnvironmentId) in cui si esegue la distribuzione, che vengono impostati in questo esempio:

"parameters": {
  "kubeEnvironmentId" : {
    "type": "string"
  },
  "customLocationId" : {
    "type": "string"
  }
}

Sia i siti che i piani devono fare riferimento alla posizione personalizzata tramite un extendedLocation campo. Come illustrato in questo esempio troncato, extendedLocation si trova all'esterno di properties, come peer a kind e location:

{
  "type": "Microsoft.Web/serverfarms",
  ...
  {
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
  }
}

La risorsa di piano deve usare il valore Kubernetes (K1) per SKU, il kind campo deve essere linux,kubernetese la reserved proprietà deve essere true, poiché si tratta di una distribuzione Linux. È anche necessario impostare e extendedLocationkubeEnvironmentProfile.id sull'ID percorso personalizzato e l'ID dell'ambiente Kubernetes, che potrebbe essere simile alla sezione di esempio seguente:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "kind": "linux,kubernetes",
    "sku": {
      "name": "K1",
      "tier": "Kubernetes"
    },
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
    "properties": {
      "kubeEnvironmentProfile": {
        "id": "[parameters('kubeEnvironmentId')]"
      },
      "reserved": true
    }
  }
]

Creare l'app per le funzioni

La risorsa dell'app per le funzioni è definita da una risorsa di tipo Microsoft.Web/sites e kind che include functionapp, almeno.

Il modo in cui si definisce una risorsa dell'app per le funzioni dipende dal fatto che si stia ospitando in Linux o in Windows:

Per un elenco delle impostazioni dell'applicazione necessarie durante l'esecuzione in Windows, vedere Configurazione dell'applicazione. Per un esempio di file Bicep/modello di Azure Resource Manager, vedere l'app per le funzioni ospitata in Windows in un modello di piano a consumo.

Per un elenco delle impostazioni dell'applicazione necessarie durante l'esecuzione in Windows, vedere Configurazione dell'applicazione.

Nota

Se si sceglie di definire facoltativamente il piano a consumo, è necessario impostare la proprietà nell'app serverFarmId in modo che punti all'ID risorsa del piano. Assicurarsi che l'app per le funzioni abbia un'impostazione dependsOn che faccia riferimento anche al piano. Se non è stato definito in modo esplicito un piano, ne viene creato uno.

Impostare la serverFarmId proprietà nell'app in modo che punti all'ID risorsa del piano. Assicurarsi che l'app per le funzioni abbia un'impostazione dependsOn che faccia riferimento anche al piano.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "appSettings": [
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "WEBSITE_CONTENTSHARE",
            "value": "[toLower(parameters('functionAppName'))]"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          }
        ]
      }
    }
  }
]

Per un esempio completo end-to-end, vedere questo modello di azuredeploy.json.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "alwaysOn": true,
        "appSettings": [
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          }
        ]
      }
    }
  }
]

Per un esempio completo end-to-end, vedere questo modello di azuredeploy.json.

Origini di distribuzione

Il file Bicep o il modello di Resource Manager può anche definire una distribuzione per il codice della funzione, che può includere questi metodi:

Origini di distribuzione

Il file Bicep o il modello arm possono anche definire una distribuzione per il codice della funzione usando un pacchetto di distribuzione ZIP.

Per poter distribuire l'applicazione usando Azure Resource Manager, è importante comprendere come vengono distribuite le risorse in Azure. Nella maggior parte degli esempi, le configurazioni di primo livello vengono applicate tramite siteConfig. È importante impostare le configurazioni a un livello superiore perché forniscono informazioni al motore di runtime e di distribuzione di Funzioni di Azure. Le informazioni di primo livello sono necessarie prima dell'applicazione della risorsa figlio sourcecontrols/web . Sebbene sia possibile configurare queste impostazioni nella risorsa a livello config/appSettings figlio, in alcuni casi l'app per le funzioni deve essere distribuita primaconfig/appSettings dell'applicazione.

Pacchetto di distribuzione ZIP

La distribuzione zip è un modo consigliato per distribuire il codice dell'app per le funzioni. Per impostazione predefinita, le funzioni che usano la distribuzione ZIP vengono eseguite nel pacchetto di distribuzione stesso. Per altre informazioni, inclusi i requisiti per un pacchetto di distribuzione, vedere Distribuzione zip per Funzioni di Azure. Quando si usa l'automazione della distribuzione delle risorse, è possibile fare riferimento al pacchetto di distribuzione .zip nel modello Bicep o ARM.

Per usare la distribuzione zip nel modello, impostare l'impostazione WEBSITE_RUN_FROM_PACKAGE nell'app su 1 e includere la definizione della /zipDeploy risorsa.

Per un piano a consumo in Linux, impostare invece l'URI del pacchetto di distribuzione direttamente nell'impostazione WEBSITE_RUN_FROM_PACKAGE , come illustrato in questo modello di esempio.

Questo esempio aggiunge un'origine di distribuzione ZIP a un'app esistente:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "functionAppName": {
      "type": "string",
      "metadata": {
        "description": "The name of the Azure Function app."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location into which the resources should be deployed."
      }
    },
    "packageUri": {
      "type": "string",
      "metadata": {
        "description": "The zip content url."
      }
    }
  },
  "resources": [
    {
      "name": "[concat(parameters('functionAppName'), '/ZipDeploy')]",
      "type": "Microsoft.Web/sites/extensions",
      "apiVersion": "2021-02-01",
      "location": "[parameters('location')]",
      "properties": {
        "packageUri": "[parameters('packageUri')]"
      }
    }
  ]
}

Tenere presente quanto segue quando si includono le risorse di distribuzione ZIP nel modello:

  • Deve packageUri essere una posizione accessibile da Funzioni. Prendere in considerazione l'uso dell'archiviazione BLOB di Azure con una firma di accesso condiviso. Dopo la scadenza della firma di accesso condiviso, Funzioni non può più accedere alla condivisione per le distribuzioni. Quando si rigenera la firma di accesso condiviso, ricordarsi di aggiornare l'impostazione WEBSITE_RUN_FROM_PACKAGE con il nuovo valore URI.

  • Quando si imposta WEBSITE_RUN_FROM_PACKAGE su un URI, è necessario sincronizzare manualmente i trigger.

  • Assicurarsi di impostare sempre tutte le impostazioni dell'applicazione necessarie nella appSettings raccolta durante l'aggiunta o l'aggiornamento delle impostazioni. Le impostazioni esistenti non impostate in modo esplicito vengono rimosse dall'aggiornamento. Per altre informazioni, vedere Configurazione dell'applicazione.

  • Funzioni non supporta Distribuzione Web (msdeploy) per le distribuzioni di pacchetti. È invece necessario usare la distribuzione ZIP nelle pipeline di distribuzione e nell'automazione. Per altre informazioni, vedere Distribuzione zip per Funzioni di Azure.

Compilazioni remote

Il processo di distribuzione presuppone che il file .zip usato o una distribuzione ZIP contenga un'app pronta per l'esecuzione. Ciò significa che per impostazione predefinita non vengono eseguite personalizzazioni.

Esistono tuttavia scenari che richiedono la ricompilazione remota dell'app, ad esempio quando è necessario eseguire il pull di pacchetti specifici di Linux in Python o Node.js app sviluppate in un computer Windows. In questo caso, è possibile configurare Funzioni per eseguire una compilazione remota sul codice dopo la distribuzione zip.

Il modo in cui si richiede una compilazione remota dipende dal sistema operativo in cui si sta distribuendo:

Quando un'app viene distribuita in Windows, vengono eseguiti comandi specifici del linguaggio (ad esempio dotnet restore per le app C# o npm install per le app Node.js).

Per abilitare gli stessi processi di compilazione che si ottengono con l'integrazione continua, aggiungere SCM_DO_BUILD_DURING_DEPLOYMENT=true alle impostazioni dell'applicazione nel codice di distribuzione e rimuovere completamente .WEBSITE_RUN_FROM_PACKAGE

Contenitori Linux

Se si distribuisce un'app per le funzioni in contenitori in un piano Funzioni di Azure Premium o Dedicato, è necessario:

Per altre informazioni, vedere Configurazione dell'applicazione.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "appSettings": [
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_URL",
            "value": "[parameters('dockerRegistryUrl')]"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_USERNAME",
            "value": "[parameters('dockerRegistryUsername')]"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_PASSWORD",
            "value": "[parameters('dockerRegistryPassword')]"
          },
          {
            "name": "WEBSITES_ENABLE_APP_SERVICE_STORAGE",
            "value": "false"
          }
        ],
        "linuxFxVersion": "DOCKER|myacr.azurecr.io/myimage:mytag"
      }
    }
  }
]

Quando si distribuiscono funzioni in contenitori in App Azure Container, il modello deve:

  • Impostare il kind campo su un valore di functionapp,linux,container,azurecontainerapps.
  • Impostare la managedEnvironmentId proprietà del sito sull'URI completo dell'ambiente App contenitore.
  • Aggiungere un collegamento alla risorsa nella raccolta del dependsOn sito durante la creazione di una Microsoft.App/managedEnvironments risorsa contemporaneamente al sito.

La definizione di un'app per le funzioni in contenitori distribuita da un registro contenitori privato in un ambiente app contenitore esistente potrebbe essere simile all'esempio seguente:

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "kind": "functionapp,linux,container,azurecontainerapps",
    "location": "[parameters('location')]",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[parameters('hostingPlanName')]",
      "siteConfig": {
        "linuxFxVersion": "DOCKER|myacr.azurecr.io/myimage:mytag",
        "appSettings": [
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          }
        ],
      },
      "managedEnvironmentId": "[parameters('managedEnvironmentId')]"
    }
  }
]

Quando si distribuiscono funzioni in Azure Arc, il valore impostato per il kind campo della risorsa dell'app per le funzioni dipende dal tipo di distribuzione:

Tipo di distribuzione kind valore campo
Distribuzione solo codice functionapp,linux,kubernetes
Distribuzione di contenitori functionapp,linux,kubernetes,container

È anche necessario impostare come customLocationId si è fatto per la risorsa del piano di hosting.

La definizione di un'app per le funzioni in contenitori, usando un'immagine di avvio rapido di .NET 6, potrebbe essere simile all'esempio seguente:

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "kind": "kubernetes,functionapp,linux,container",
    "location": "[parameters('location')]",
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[parameters('hostingPlanName')]",
      "siteConfig": {
        "linuxFxVersion": "DOCKER|mcr.microsoft.com/azure-functions/4-dotnet-isolated6.0-appservice-quickstart",
        "appSettings": [
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          }
        ],
        "alwaysOn": true
      }
    }
  }
]

Configurazione dell'applicazione

Funzioni offre le opzioni seguenti per la configurazione dell'app per le funzioni in Azure:

Impostazione Proprietà Microsoft.Web/sites
Impostazioni sito siteConfig
Impostazioni applicazione siteConfig.appSettings Collezione

Per la proprietà sono necessarie le impostazioni del siteConfig sito seguenti:

Queste impostazioni dell'applicazione sono obbligatorie (o consigliate) per un sistema operativo specifico e un'opzione di hosting:

Queste impostazioni dell'applicazione sono necessarie per le distribuzioni di contenitori:

Queste impostazioni sono necessarie solo quando si esegue la distribuzione da un registro contenitori privato:

Tenere presenti queste considerazioni quando si usano le impostazioni del sito e dell'applicazione usando i file Bicep o i modelli di Resource Manager:

  • Quando è necessario impostare WEBSITE_CONTENTSHARE in una distribuzione automatizzata, è necessario tenere presenti considerazioni importanti. Per indicazioni dettagliate, vedere le informazioni di WEBSITE_CONTENTSHARE riferimento.

  • È consigliabile definire sempre le impostazioni dell'applicazione come raccolta siteConfig/appSettings della Microsoft.Web/sites risorsa creata, come illustrato negli esempi di questo articolo. In questo modo si garantisce che le impostazioni necessarie per l'esecuzione dell'app per le funzioni siano disponibili all'avvio iniziale.

  • Quando si aggiungono o aggiornano le impostazioni dell'applicazione usando i modelli, assicurarsi di includere tutte le impostazioni esistenti con l'aggiornamento. Questa operazione deve essere eseguita perché le chiamate dell'API REST di aggiornamento sottostante sostituiscono l'intera /config/appsettings risorsa. Se si rimuovono le impostazioni esistenti, l'app per le funzioni non verrà eseguita. Per aggiornare a livello di codice le singole impostazioni dell'applicazione, è invece possibile usare l'interfaccia della riga di comando di Azure, Azure PowerShell o il portale di Azure per apportare queste modifiche. Per altre informazioni, vedere Usare le impostazioni dell'applicazione.

Distribuzioni di slot

Funzioni consente di distribuire versioni diverse del codice in endpoint univoci nell'app per le funzioni. In questo modo è più semplice sviluppare, convalidare e distribuire gli aggiornamenti delle funzioni senza influire sulle funzioni in esecuzione nell'ambiente di produzione. Gli slot di distribuzione sono una funzionalità del servizio app Azure. Il numero di slot disponibili dipende dal piano di hosting. Per altre informazioni, vedere Funzioni di Azure funzioni degli slot di distribuzione.

Una risorsa slot viene definita nello stesso modo di una risorsa dell'app per le funzioni (Microsoft.Web/sites), ma si usa l'identificatore di Microsoft.Web/sites/slots risorsa. Per una distribuzione di esempio (sia nei modelli Bicep che arm) che crea sia un ambiente di produzione che uno slot di staging in un piano Premium, vedere App per le funzioni di Azure con uno slot di distribuzione.

Per informazioni su come eseguire lo scambio usando i modelli, vedere Automatizzare con i modelli di Resource Manager.

Quando si lavora con le distribuzioni di slot, tenere presenti le considerazioni seguenti:

  • Non impostare in modo esplicito l'impostazione WEBSITE_CONTENTSHARE nella definizione dello slot di distribuzione. Questa impostazione viene generata automaticamente quando l'app viene creata nello slot di distribuzione.

  • Quando si scambiano gli slot, alcune impostazioni dell'applicazione vengono considerate "permanenti", in quanto rimangono nello slot e non con il codice da scambiare. È possibile definire tale impostazione dello slot includendo "slotSetting":true nella definizione specifica dell'impostazione dell'applicazione nel modello. Per altre informazioni, vedere Gestire le impostazioni.

Distribuzioni protette

È possibile creare l'app per le funzioni in una distribuzione in cui una o più risorse sono state protette tramite l'integrazione con le reti virtuali. L'integrazione della rete virtuale per l'app per le funzioni è definita da una Microsoft.Web/sites/networkConfig risorsa. Questa integrazione dipende sia dall'app per le funzioni a cui si fa riferimento che dalle risorse di rete virtuale. L'app per le funzioni può anche dipendere da altre risorse di rete privata, ad esempio endpoint privati e route. Per altre informazioni, vedere Opzioni di rete di Funzioni di Azure.

Quando si crea una distribuzione che usa un account di archiviazione protetto, è necessario impostare in modo esplicito l'impostazione WEBSITE_CONTENTSHARE e creare la risorsa di condivisione file denominata in questa impostazione. Assicurarsi di creare una Microsoft.Storage/storageAccounts/fileServices/shares risorsa usando il valore di WEBSITE_CONTENTSHARE, come illustrato in questo esempio (file Bicep del modello|di Resource Manager). È anche necessario impostare la proprietà vnetContentShareEnabled del sito su true.

Nota

Quando queste impostazioni non fanno parte di una distribuzione che usa un account di archiviazione protetto, viene visualizzato questo errore durante la convalida della distribuzione: Could not access storage account using provided connection string.

Questi progetti forniscono esempi di modelli Bicep e ARM di come distribuire le app per le funzioni in una rete virtuale, incluse le restrizioni di accesso alla rete:

Scenario con restrizioni Descrizione
Creare un'app per le funzioni con l'integrazione della rete virtuale L'app per le funzioni viene creata in una rete virtuale con accesso completo alle risorse in tale rete. L'accesso in ingresso e in uscita all'app per le funzioni non è limitato. Per altre informazioni, vedere Integrazione della rete virtuale.
Creare un'app per le funzioni che accede a un account di archiviazione protetto L'app per le funzioni creata usa un account di archiviazione protetto a cui funzioni accede tramite endpoint privati. Per altre informazioni, vedere Limitare l'account di archiviazione a una rete virtuale.
Creare un'app per le funzioni e un account di archiviazione che usano entrambi gli endpoint privati L'app per le funzioni creata può essere accessibile solo usando endpoint privati e usa endpoint privati per accedere alle risorse di archiviazione. Per altre informazioni, vedere Endpoint privati.

Impostazioni di rete con restrizioni

Potrebbe anche essere necessario usare queste impostazioni quando l'app per le funzioni presenta restrizioni di rete:

Impostazione valore Descrizione
WEBSITE_CONTENTOVERVNET 1 Impostazione dell'applicazione che consente all'app per le funzioni di ridimensionarsi quando l'account di archiviazione è limitato a una rete virtuale. Per altre informazioni, vedere Limitare l'account di archiviazione a una rete virtuale.
vnetrouteallenabled 1 Impostazione del sito che forza tutto il traffico dall'app per le funzioni a usare la rete virtuale. Per altre informazioni, vedere Integrazione della rete virtuale a livello di area. Questa impostazione del sito sostituisce l'impostazione WEBSITE_VNET_ROUTE_ALLdell'applicazione .

Considerazioni sulle restrizioni di rete

Quando si limita l'accesso all'account di archiviazione tramite gli endpoint privati, non è possibile accedere all'account di archiviazione tramite il portale o qualsiasi dispositivo all'esterno della rete virtuale. È possibile concedere l'accesso all'indirizzo IP protetto o alla rete virtuale nell'account di archiviazione gestendo la regola di accesso di rete predefinita.

Creare il modello

Gli esperti con modelli Bicep o ARM possono codificare manualmente le distribuzioni usando un semplice editor di testo. Per il resto di noi, esistono diversi modi per semplificare il processo di sviluppo:

  • Visual Studio Code: sono disponibili estensioni che consentono di usare sia i fileBicep che i modelli arm. È possibile usare questi strumenti per assicurarsi che il codice sia corretto e forniscano una convalida di base.

  • portale di Azure: quando si crea l'app per le funzioni e le risorse correlate nel portale, la schermata finale Rivedi e crea include un modello per il collegamento di automazione.

    Scaricare il collegamento al modello dal processo di creazione Funzioni di Azure nel portale di Azure.

    Questo collegamento mostra il modello di Resource Manager generato in base alle opzioni scelte nel portale. Anche se questo modello può essere un po' complesso quando si crea un'app per le funzioni con molte nuove risorse, può fornire un buon riferimento per l'aspetto del modello di Resource Manager.

Convalidare il modello

Quando si crea manualmente il file del modello di distribuzione, è importante convalidare il modello prima della distribuzione. Tutti i metodi di distribuzione convalidano la sintassi del modello e generano un validation failed messaggio di errore come illustrato nell'esempio JSON seguente:

{"error":{"code":"InvalidTemplate","message":"Deployment template validation failed: 'The resource 'Microsoft.Web/sites/func-xyz' is not defined in the template. Please see https://aka.ms/arm-template for usage details.'.","additionalInfo":[{"type":"TemplateViolation","info":{"lineNumber":0,"linePosition":0,"path":""}}]}}

È possibile usare i metodi seguenti per convalidare il modello prima della distribuzione:

L'attività di distribuzione v2 del gruppo di risorse di Azure seguente con deploymentMode: 'Validation' indica ad Azure Pipelines di convalidare il modello.

- task: AzureResourceManagerTemplateDeployment@3
  inputs:
    deploymentScope: 'Resource Group'
    subscriptionId: # Required subscription ID
    action: 'Create Or Update Resource Group'
    resourceGroupName: # Required resource group name
    location: # Required when action == Create Or Update Resource Group
    templateLocation: 'Linked artifact'
    csmFile: # Required when  TemplateLocation == Linked Artifact
    csmParametersFile: # Optional
    deploymentMode: 'Validation'

È anche possibile creare un gruppo di risorse di test per trovare gli errori preliminari e di distribuzione .

Distribuire il modello

È possibile usare uno dei modi seguenti per distribuire il file e il modello Bicep:

Pulsante Distribuisci in Azure

Nota

Questo metodo non supporta attualmente la distribuzione di file Bicep.

Sostituire <url-encoded-path-to-azuredeploy-json> con una versione con codifica URL del percorso non elaborato del file azuredeploy.json in GitHub.

Ecco un esempio che usa markdown:

[![Deploy to Azure](https://azuredeploy.net/deploybutton.png)](https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>)

Ecco un esempio che usa HTML:

<a href="https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>" target="_blank"><img src="https://azuredeploy.net/deploybutton.png"></a>

Distribuire tramite PowerShell

I comandi di PowerShell seguenti creano un gruppo di risorse e distribuiscono un modello di file/Arm Bicep che crea un'app per le funzioni con le risorse necessarie. Per l'esecuzione in locale, è necessario che Azure PowerShell sia installato. Eseguire Connect-AzAccount per accedere.

# Register Resource Providers if they're not already registered
Register-AzResourceProvider -ProviderNamespace "microsoft.web"
Register-AzResourceProvider -ProviderNamespace "microsoft.storage"

# Create a resource group for the function app
New-AzResourceGroup -Name "MyResourceGroup" -Location 'West Europe'

# Deploy the template
New-AzResourceGroupDeployment -ResourceGroupName "MyResourceGroup" -TemplateFile azuredeploy.json  -Verbose

Per testare questa distribuzione, è possibile usare un modello come questo che crea un'app per le funzioni in Windows in un piano a consumo.

Passaggi successivi

Altre informazioni su come sviluppare e configurare le Funzioni di Azure.