Distribuzione basata su pacchetti per Funzioni di Azure

Questo articolo descrive come creare un pacchetto di deployment .zip pronto all'uso, distribuire il pacchetto su Azure e configurare la tua app funzione per farla eseguire direttamente dal pacchetto. Puoi distribuire utilizzando Funzioni di Azure Core Tools, interfaccia della riga di comando di Azure o le API REST di deployment.

La distribuzione basata su pacchetti è l'impostazione predefinita per le app per le funzioni che vengono eseguite a partire dal codice. La tecnologia di distribuzione e la configurazione dei pacchetti dipendono dal piano di hosting. Seleziona il tuo piano di hosting in cima a questo articolo.

Funzioni di Azure offre l'intera gamma di opzioni di implementazione continua e integrazione che Servizio app di Azure offre. Per altre informazioni, vedere Distribuzione continua per Funzioni di Azure.

Distribuzione dei pacchetti tramite piano di hosting

La tabella seguente riassume il processo di distribuzione e la configurazione dei pacchetti per ciascun piano di hosting:

Piano di hosting Processo di distribuzione Configurazione del pacchetto
Piano di consumo flessibile Distribuzione gestita dei pacchetti Viene eseguito di default dal pacchetto distribuito. Non impostare WEBSITE_RUN_FROM_PACKAGE.
Piano Premium Distribuzione tramite ZIP Imposta WEBSITE_RUN_FROM_PACKAGE su 1 per eseguire dal pacchetto distribuito.
Piano dedicato (servizio app) Distribuzione tramite ZIP Imposta WEBSITE_RUN_FROM_PACKAGE su 1 per eseguire dal pacchetto distribuito.
Piano di consumo su Windows Distribuzione tramite ZIP Imposta WEBSITE_RUN_FROM_PACKAGE su 1 per eseguire dal pacchetto distribuito.
Piano di consumo su Linux URL di compilazione remota o pacchetto esterno Usa un URL di pacchetto esterno per un pacchetto costruito localmente.
App contenitore di Azure Distribuzione dell'immagine del container La distribuzione del codice basata su pacchetti non è applicabile.

Annotazioni

Il contenuto di questo articolo non è rilevante per il piano di hosting attualmente selezionato. Per scegliere un piano diverso, usa il selettore in cima a questo articolo. Per un confronto di tutti i piani di hosting, consulta Funzioni di Azure hosting options.

Le app per le funzioni ospitate in App contenitore di Azure vengono distribuite come immagini di contenitori, non come pacchetti .zip. Per creare e distribuire un'app di funzioni basata su immagini, vedi Creare un'app di funzioni su App contenitore di Azure usando codice.

Crea un pacchetto di distribuzione

Nella maggior parte dei casi, non è necessario creare il pacchetto di distribuzione da solo. Questi metodi di distribuzione basati su strumenti creano il pacchetto come parte del processo di pubblicazione:

Per Azure Pipelines deployment, i passaggi di compilazione della pipeline creano l'archivio .zip e lo passano all'AzureFunctionApp attività di distribuzione.

Quando devi lavorare direttamente con un pacchetto di deployment pronto all'uso, crea il pacchetto usando func pack. Ad esempio, crea tu stesso il pacchetto quando distribuisci usando un URL esterno del pacchetto.

Puoi anche creare manualmente l'archivio .zip. Quando crei l'archivio manualmente, segui questi requisiti di struttura del pacchetto.

Requisiti del pacchetto di distribuzione

L'archivio zip distribuito deve contenere tutti i file necessari per eseguire l'app per le funzioni. È possibile creare manualmente un archivio ZIP dal contenuto di una cartella del progetto di Funzioni usando funzionalità di compressione predefinite .zip o strumenti non Microsoft.

L'archivio deve includere il file host.json nella radice della cartella estratta. Lo stack di linguaggio selezionato per l'app per le funzioni crea altri requisiti:

Importante

Per le lingue che generano l'output compilato per la distribuzione, assicurarsi di comprimere i contenuti della cartella di output che si intende pubblicare e non l'intera cartella del progetto. Quando Funzioni estrae il contenuto dell'archivio ZIP, il file host.json deve esistere nella radice del pacchetto.

Un processo di deployment zip estrae i file e le cartelle dell'archivio .zip nella wwwroot directory. Se includi la cartella genitore quando crei l'archivio, il sistema non trova i file che si aspetta di vedere in wwwroot.

Distribuzione di un pacchetto

Flex Consumption utilizza la distribuzione del pacchetto per memorizzare un pacchetto pronto per l'esecuzione nel contenitore di archiviazione della distribuzione dell'app. L'app funziona direttamente da questo pacchetto. Non impostare l'impostazione dell'applicazione WEBSITE_RUN_FROM_PACKAGE.

Distribuisci il pacchetto utilizzando Core Tools, Visual Studio Code o interfaccia della riga di comando di Azure. Questi strumenti selezionano automaticamente il comportamento corretto di distribuzione del pacchetto per un'app Flex Consumption.

Questi strumenti eseguono una distribuzione push inviando il pacchetto all'endpoint di distribuzione dell'app. Per Flex Consumption, questi client inviano il pacchetto sull'host /api/publish dell'app scm . Quando l'endpoint di distribuzione è raggiungibile solo tramite un endpoint privato, il computer, il runner o l'agente che esegue la distribuzione devono avere connettività di rete e risoluzione DNS per l'endpoint privato di distribuzione. Il servizio di distribuzione memorizza il pacchetto elaborato nel container configurato; caricare direttamente un pacchetto su questo container non lo distribuisce. Per distribuire senza dover inviare dal client di avvio all'endpoint di distribuzione, usa un modello di distribuzione Bicep o ARM con un URL del pacchetto a cui il servizio di distribuzione può accedere.

Eseguire la distribuzione usando l'interfaccia della riga di comando di Azure

Usa il az functionapp deployment source config-zip comando per distribuire un pacchetto:

az functionapp deployment source config-zip --resource-group <RESOURCE_GROUP> \
  --name <APP_NAME> --src <ZIP_FILE_PATH>

Aggiungi --build-remote true quando il progetto sorgente richiede una build remota. Non richiedere una compilazione remota per un pacchetto che func pack è già stato compilato in formato pronto per l'esecuzione, come un pacchetto di distribuzione Go.

Per configurare lo storage di distribuzione o recuperare una distribuzione precedente, vedi Crea e gestisci app di funzione nel piano Flex Consumption.

Distribuzione di un pacchetto

Le app Premium, Dedicate e Consumption Plane utilizzano l'API di deployment zip. Il servizio di distribuzione esegue queste azioni:

  • Elimina i file rimasti dalle installazioni precedenti.
  • Esegui script di distribuzione e altre personalizzazioni di distribuzione.
  • Scrivi i log di distribuzione.
  • La funzione di sincronizzazione si attiva.

Importante

In una distribuzione zip, i file della distribuzione precedente vengono cancellati o aggiornati quando facevano parte di quella implementazione. Il processo di distribuzione conserva altri file e directory nella tua app di funzione che non facevano parte del deployment precedente. Per i dettagli di implementazione, consulta la guida di riferimento per la distribuzione ZIP.

Eseguire la distribuzione usando l'interfaccia della riga di comando di Azure

Usa interfaccia della riga di comando di Azure per attivare una distribuzione push. Eseguire la distribuzione push di un file ZIP nell'app per le funzioni usando il comando az functionapp deployment source config-zip. Per usare questo comando, è necessario utilizzare l'interfaccia della riga di comando di Azure 2.0.21 o versione successiva. Per visualizzare la versione dell'interfaccia della riga di comando di Azure in uso, usare il az --version comando .

Nel comando seguente sostituire il segnaposto <zip_file_path> con il percorso del file ZIP. Sostituire anche <app_name> con il nome univoco dell'app per le funzioni e sostituire <resource_group> con il nome del gruppo di risorse.

az functionapp deployment source config-zip -g <resource_group> -n \
<app_name> --src <zip_file_path>

Questo comando distribuisce i file di progetto dal file .zip alla tua app funzione in Azure e riavvia l'app.

Quando si utilizza l'interfaccia della riga di comando di Azure nel computer locale, <zip_file_path> è il percorso del file ZIP nel computer in uso. È anche possibile eseguire l'interfaccia della riga di comando di Azure in Azure Cloud Shell. Quando si utilizza Cloud Shell, è innanzitutto necessario caricare il file ZIP per la distribuzione nell'account File di Azure associato a Cloud Shell. In tal caso <zip_file_path> è il percorso di archiviazione utilizzato dall'account Cloud Shell. Per altre informazioni, vedere Rendere persistenti i file in Azure Cloud Shell.

Distribuire il file con estensione zip con le API REST

È possibile usare le API REST del servizio distribuzione per distribuire il file ZIP nella propria app in Azure. Per eseguire la distribuzione, inviare una richiesta POST a https://<app_name>.scm.azurewebsites.net/api/zipdeploy. La richiesta POST deve contenere il file ZIP nel corpo del messaggio. Le credenziali di distribuzione per l'app vengono fornite nella richiesta usando l'autenticazione di base HTTP. Per altre informazioni, vedere le informazioni di riferimento sulla distribuzione push tramite file ZIP.

Per l'autenticazione HTTP di base sono necessarie le credenziali di distribuzione del servizio app. Per informazioni su come impostare le credenziali di distribuzione, vedere Impostare e reimpostare le credenziali a livello di utente.

Con cURL

L'esempio seguente usa lo strumento cURL per distribuire un file con estensione zip. Sostituire i segnaposto <deployment_user>, <zip_file_path> e <app_name>. Quando richiesto da cURL, digitare la password.

curl -X POST -u <deployment_user> --data-binary "@<zip_file_path>" https://<app_name>.scm.azurewebsites.net/api/zipdeploy

Questa richiesta attiva la distribuzione push dal file ZIP caricato. È possibile esaminare le distribuzioni correnti e passate usando l'endpoint https://<app_name>.scm.azurewebsites.net/api/deployments, come illustrato nell'esempio cURL seguente. Anche in questo caso, sostituire il segnaposto <app_name> con il nome dell'app e <deployment_user> con il nome utente delle credenziali di distribuzione.

curl -u <deployment_user> https://<app_name>.scm.azurewebsites.net/api/deployments

Distribuzione zip asincrona

Durante la distribuzione in modo sincrono, è possibile che vengano visualizzati errori correlati ai timeout di connessione. Aggiungere ?isAsync=true all'URL per distribuire in modo asincrono. Si riceve una risposta non appena il file ZIP viene caricato con un'intestazione Location che punta all'URL dello stato della distribuzione consultabile. Quando si esegue il polling dell'URL fornito nell'intestazione Location , si riceve una risposta HTTP 202 (accettata) mentre il processo è in corso e una risposta HTTP 200 (OK) dopo l'espansione dell'archivio e la distribuzione viene completata correttamente.

Autenticazione di Microsoft Entra

Un'alternativa all'uso dell'autenticazione HTTP BASIC per la distribuzione zip consiste nell'usare un'identità Microsoft Entra. L'identità Di Microsoft Entra potrebbe essere necessaria se l'autenticazione HTTP BASIC è disabilitata per il sito SCM.

È necessario un token di accesso Microsoft Entra valido per l'utente o l'entità servizio che esegue la distribuzione. È possibile recuperare un token di accesso usando il az account get-access-token comando dell'interfaccia della riga di comando di Azure. Il token di accesso viene usato nell'intestazione Authentication della richiesta HTTP POST.

curl -X POST \
    --data-binary "@<zip_file_path>" \
    -H "Authorization: Bearer <access_token>" \
    "https://<app_name>.scm.azurewebsites.net/api/zipdeploy"

Con PowerShell

L'esempio seguente usa Publish-AzWebapp per caricare il file .zip. Sostituire i segnaposto <group-name>, <app-name> e <zip-file-path>.

Publish-AzWebapp -ResourceGroupName <group-name> -Name <app-name> -ArchivePath <zip-file-path>

Questa richiesta attiva la distribuzione push dal file ZIP caricato.

Per esaminare le distribuzioni correnti e precedenti, eseguire i comandi seguenti. Sostituire di nuovo i segnaposti <deployment-user>, <deployment-password>, e <app-name>.

$username = "<deployment-user>"
$password = "<deployment-password>"
$apiUrl = "https://<app-name>.scm.azurewebsites.net/api/deployments"
$base64AuthInfo = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1}" -f $username, $password)))
$userAgent = "powershell/1.0"
Invoke-RestMethod -Uri $apiUrl -Headers @{Authorization=("Basic {0}" -f $base64AuthInfo)} -UserAgent $userAgent -Method GET

Distribuisci utilizzando Bicep o un template di Azure Resource Manager

Puoi distribuire un pacchetto su un'app Flex Consumption come parte di un template Bicep o Azure Resource Manager (ARM). Definisci una Microsoft.Web/sites/extensions risorsa che utilizza l'estensione /onedeploy e fornisce l'URL del pacchetto remoto nella packageUri proprietà.

Devi nominare il file del pacchetto released-package.zip. L'host Functions deve essere in grado di accedere sia all'URL remoto del pacchetto sia al container di archiviazione di distribuzione. Caricare direttamente il pacchetto nel container di distribuzione non lo distribuisce.

Per esempi di template Bicep e ARM, vedi Definire il pacchetto di distribuzione Flex Consumption.

Distribuisci utilizzando un template di Azure Resource Manager

Puoi usare l'estensione modello Azure Resource Manager (ARM) ZipDeploy per inviare il tuo file .zip nella tua app di funzione.

Esempio di template ARM ZipDeploy

Questo modello include sia uno slot di produzione che quello di staging e viene distribuito in uno o nell'altro. In genere, questo modello si usa per eseguire la distribuzione nello slot di staging e poi effettuare lo scambio, in modo da eseguire il nuovo pacchetto ZIP nello slot di produzione.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "appServiceName": {
      "type": "string"
    },
    "deployToProduction": {
      "type": "bool",
      "defaultValue": false
    },
    "slot": {
      "type": "string",
      "defaultValue": "staging"
    },
    "packageUri": {
      "type": "secureString"
    }
  },
  "resources": [
    {
      "condition": "[parameters('deployToProduction')]",
      "type": "Microsoft.Web/sites/extensions",
      "apiVersion": "2021-02-01",
      "name": "[format('{0}/ZipDeploy', parameters('appServiceName'))]",
      "properties": {
        "packageUri": "[parameters('packageUri')]",
        "appOffline": true
      }
    },
    {
      "condition": "[not(parameters('deployToProduction'))]",
      "type": "Microsoft.Web/sites/slots/extensions",
      "apiVersion": "2021-02-01",
      "name": "[format('{0}/{1}/ZipDeploy', parameters('appServiceName'), parameters('slot'))]",
      "properties": {
        "packageUri": "[parameters('packageUri')]",
        "appOffline": true
      }
    }
  ]
}

Per la distribuzione iniziale, distribuisci direttamente nello slot di produzione. Per altre informazioni, vedere Distribuzioni degli slot.

Eseguire le funzioni dal pacchetto di distribuzione

Eseguire direttamente dal pacchetto di distribuzione salta la copia dei file nella wwwroot directory. Invece, il runtime di Functions monta il pacchetto come directory wwwroot di sola lettura. Questo approccio:

  • Riduce i problemi di blocco delle copie dei file.
  • Verifica i file in esecuzione nell'app.
  • Migliora le prestazioni di distribuzione di Azure Resource Manager.
  • Può ridurre i tempi di avvio a freddo, in particolare per app JavaScript con grandi alberi di pacchetti npm.

Configurazione del pacchetto Flex Consumption

Le app Flex Consumption vengono eseguite di default da un pacchetto. Non aggiungere l'impostazione dell'app WEBSITE_RUN_FROM_PACKAGE . Le impostazioni di distribuzione, compresi il contenitore di archiviazione e il relativo metodo di autenticazione, sono proprietà della risorsa dell'app per le funzioni. Per ulteriori informazioni, vedi Distribuzione.

Configurazione Premium e Pacchetto dedicato

Imposta WEBSITE_RUN_FROM_PACKAGE su 1 per eseguire direttamente dal pacchetto distribuito in locale. L'esecuzione memorizza il pacchetto nella c:\home\data\SitePackages cartella su Windows o /home/data/SitePackages nella cartella su Linux.

Configurazione del pacchetto di consumo

Il valore supportato WEBSITE_RUN_FROM_PACKAGE dipende dal sistema operativo:

Sistema operativo Valore Behavior
Windows 1 L'app viene eseguita da un pacchetto nella c:\home\data\SitePackages cartella.
Linux <URL> L'app viene eseguita dal pacchetto all'URL specificato. Usa un container privato Archiviazione BLOB di Azure accessibile utilizzando un'identità gestita.

Importante

Le app per le funzioni sono ancora in esecuzione con il runtime v3 di fine vita su Linux in un piano a consumo fino al 30 settembre 2026, dopodiché smetteranno di funzionare. Per evitare interruzioni del servizio, eseguire la migrazione dell'app al runtime v4.

L'opzione per ospitare le app per le funzioni in Linux in un piano a consumo viene ritirata il 30 settembre 2028. Il piano a consumo di Linux non riceverà nuove funzionalità o versioni linguistiche. Le applicazioni in esecuzione su Windows in un piano di consumo non sono attualmente interessate. Eseguire la migrazione delle app al piano Flex Consumption prima della data di ritiro.

Considerazioni sulla distribuzione dei pacchetti

Tieni a mente questi requisiti e limitazioni quando distribuisci ed esegui la tua function app da un pacchetto:

  • Il pacchetto deve utilizzare .zip formato. I formati tar e gzip non sono supportati.
  • La dimensione massima del pacco è di 1 GB. La distribuzione utilizza un'archiviazione temporanea durante l'estrazione dei file di progetto, quindi anche l'app deve disporre di un'archiviazione temporanea sufficiente. Il piano Consumption fornisce 500 MB di spazio temporaneo per piano.
  • Quando si esegue da un pacchetto, i file in wwwroot sono di sola lettura, anche nel portale di Azure.
  • Non puoi usare la cache locale quando esegui da un pacchetto.
  • Non impostare WEBSITE_RUN_FROM_PACKAGE quando richiedi una build remota. Invece, imposta SCM_DO_BUILD_DURING_DEPLOYMENT=true. Su Linux, imposta anche ENABLE_ORYX_BUILD=true.
  • WEBSITE_RUN_FROM_PACKAGE non funziona con MSDeploy. Usa invece la distribuzione ZIP.

Aggiungere il parametro WEBSITE_RUN_FROM_PACKAGE

Esistono diversi modi per aggiungere, aggiornare ed eliminare le impostazioni dell'app per le funzioni:

Le modifiche apportate alle impostazioni dell'app per le funzioni richiedono il riavvio dell'app per le funzioni.

Esegui da un pacchetto caricato tramite distribuzione ZIP

Imposta WEBSITE_RUN_FROM_PACKAGE su 1 prima di distribuire il pacchetto. L'API di deployment zip copia il pacchetto nella SitePackages cartella invece di estrarne il contenuto in wwwroot. La distribuzione crea anche un filepackagename.txt che identifica il pacchetto da montare. Dopo il riavvio dell'app, il pacchetto si monta come cartella di sola wwwroot lettura. Le app Linux Consumption non supportano questo valore di impostazione e devono invece essere eseguite da un URL di pacchetto esterno.

Quando il deployment riavvia l'app, le esecuzioni di funzione attualmente in esecuzione terminano. Per informazioni su come scrivere funzioni in grado di gestire i riavvii in modo sicuro, vedi Scrivere funzioni senza stato.

Esegui da un URL di pacchetto esterno

Usa un URL di pacchetto esterno quando devi gestire da solo lo storage dei pacchetti. Ti serve questa opzione per eseguire un pacchetto costruito localmente su un'app Linux Consumption. Non è supportata su Flex Consumption.

Annotazioni

Non puoi modificare un'app per le funzioni esistente che usa WEBSITE_RUN_FROM_PACKAGE=1 per essere eseguita da un URL di pacchetto esterno. Per usare un URL di pacchetto esterno, crea una nuova app di funzione e imposta WEBSITE_RUN_FROM_PACKAGE l'URL del pacchetto.

Usa un contenitore privato di Archiviazione BLOB e concedi all'identità gestita dell'app per le funzioni l'accesso al pacchetto. Usa l'identità gestita perché i token SAS scadono e richiedono manutenzione. Ogni volta che pubblichi un pacchetto aggiornato, devi sincronizzare manualmente i trigger. Se aggiorni il pacchetto direttamente senza modificarne l'URL, riavvia l'app per le funzioni prima di sincronizzare i trigger.

Carica manualmente un pacchetto su Archiviazione BLOB di Azure

  1. Crea un pacchetto di distribuzione .zip.

  2. Nel portale di Azure passare all'account di archiviazione.

  3. Sotto Archiviazione dati, seleziona Container, poi crea o seleziona un contenitore privato.

  4. Carica il pacco nel container.

  5. Seleziona il blob caricato e copiane l'URL. Se non usi un'identità gestita, genera invece un URL SAS.

  6. Nella tua app di funzione, espandi Impostazioni, seleziona variabili Ambiente e poi seleziona Aggiungi nella scheda Impostazioni dell'App .

  7. Aggiungi un'impostazione con WEBSITE_RUN_FROM_PACKAGE l'URL del pacchetto come valore.

  8. Applica le modifiche, riavvia l'app e sincronizza manualmente i trigger.

Recuperare un pacchetto da Archiviazione BLOB di Azure usando un'identità gestita

È possibile configurare Archiviazione BLOB di Azure per autorizzare le richieste con Microsoft Entra ID. Questa configurazione implica che, anziché generare una chiave SAS con una scadenza, è possibile fare affidamento sull'identità gestita dell'applicazione.

Per impostazione predefinita, viene usata l'identità assegnata dal sistema dell'app. Se si vuole specificare un'identità assegnata dall'utente, è possibile impostare l'impostazione dell'app WEBSITE_RUN_FROM_PACKAGE_BLOB_MI_RESOURCE_ID sull'ID risorsa di tale identità. L'impostazione può anche accettare SystemAssigned come valore, che equivale a omettere l'impostazione.

Per abilitare lo scaricamento del pacchetto utilizzando l'identità:

  1. Assicurarsi che il BLOB sia configurato per l'accesso privato.

  2. Concedere all'identità il ruolo Lettore di dati BLOB di archiviazione con ambito che includa il BLOB del pacchetto. Per informazioni dettagliate sulla creazione dell'assegnazione di ruolo, vedere Assegnare un ruolo di Azure per l'accesso ai dati BLOB.

  3. Impostare l'impostazione dell'applicazione WEBSITE_RUN_FROM_PACKAGE sull'URL BLOB del pacchetto. Questo URL è in genere in formato https://<storage-account-name>.blob.core.windows.net/<container-name>/<path-to-package> o simile.

  4. Se si vuole specificare un'identità assegnata dall'utente, è possibile impostare l'impostazione dell'app WEBSITE_RUN_FROM_PACKAGE_BLOB_MI_RESOURCE_ID sull'ID risorsa di tale identità. L'impostazione può anche accettare SystemAssigned come valore, anche se questa operazione equivale a omettere completamente l'impostazione. Un ID risorsa è una rappresentazione standard per una risorsa in Azure. Per un'identità gestita assegnata dall'utente, sarà /subscriptions/subid/resourcegroups/rg-name/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name. L'ID risorsa di un'identità gestita assegnata dall'utente può essere ottenuto nelle Impostazioni>Proprietà>ID per l'identità gestita assegnata dall'utente.

Personalizzazione della distribuzione

Il processo di distribuzione presuppone che il file ZIP di cui si esegue il push contenga un'app pronta da eseguire. Per impostazione predefinita, non vengono eseguite personalizzazioni. Per abilitare gli stessi processi di compilazione ottenuti con l'integrazione continua, aggiungere quanto segue alle impostazione applicazione:

SCM_DO_BUILD_DURING_DEPLOYMENT=true

Quando si usa la distribuzione push tramite file ZIP, questa impostazione è false per impostazione predefinita. L'impostazione predefinita è true per le distribuzioni tramite integrazione continua. Se impostata su true, durante la distribuzione vengono usate le impostazioni relative alla distribuzione. È possibile configurare queste impostazioni come impostazioni app o in un file di configurazione con estensione deployment disponibile nella radice del file ZIP. Per altre informazioni, vedere Repository and deployment-related settings (Repository e impostazioni relative alla distribuzione) nelle informazioni di riferimento sulla distribuzione.

Scaricare i file dell'app per le funzioni

Se hai bisogno del pacchetto esatto che la tua app esegue attualmente, scaricalo dal container gestione rete virtuale di Azure configurato per le implementazioni della tua app:

  1. Nella pagina dell'app funzione nel portale Azure, espandi Impostazioni e poi seleziona Impostazioni di distribuzione.

  2. Sotto posizione del pacchetto applicazione, annota l'account di archiviazione e il contenitore utilizzati per le distribuzioni.

  3. Vai su quell'account di archiviazione, espandi la memoria dati e poi seleziona Container.

  4. Seleziona il container di deployment, seleziona il pacchetto corrente e poi seleziona Download.

Il pacchetto scaricato contiene il contenuto dell'app integrato che hai distribuito, che potrebbe differire dal tuo progetto di origine. Ogni distribuzione sovrascrive il pacchetto corrente e il contenitore di distribuzione non fornisce la cronologia delle distribuzioni.

Per le app distribuite tramite CI/CD, mantieni il progetto sorgente nel sistema di controllo del codice sorgente e conserva gli artefatti di compilazione pronti per l’esecuzione in base ai criteri di conservazione delle release. Usa un artefatto conservato per ridistribuire un rilascio specifico. Usa il pacchetto nel container di distribuzione quando ti serve esattamente il pacchetto che l'app esegue attualmente o quando l'artefatto originale non è più disponibile.

Scaricare i file dell'app per le funzioni

Se le funzioni sono state create usando l'editor nel portale di Azure, è possibile scaricare il progetto esistente dell'app per le funzioni sotto forma di file .zip in uno dei modi seguenti:

  1. Accedere al portale di Azure e passare all'app per le funzioni.

  2. Nella scheda Panoramica selezionare Scarica contenuto dell'app. Selezionare le opzioni di download, quindi Scarica.

Screenshot che mostra la pagina del portale di Azure per scaricare il progetto dell'app per le funzioni.

Il file ZIP scaricato è nel formato corretto per essere ripubblicato nell'app per le funzioni utilizzando la distribuzione push con file ZIP. Il download dal portale consente anche di aggiungere i file necessari per aprire l'app per le funzioni direttamente in Visual Studio.

Per le app distribuite tramite CI/CD, mantieni il progetto sorgente nel sistema di controllo del codice sorgente e conserva gli artefatti di compilazione pronti per l’esecuzione in base ai criteri di conservazione delle release. Un archivio sorgente scaricato da un repository non è un pacchetto di distribuzione. Usa il tuo flusso di lavoro di distribuzione per costruire e distribuire il progetto.

Contenuti correlati

  • Last updated on