Eseguire la migrazione delle app del piano di consumo al piano di consumo Flex.

La competenza Azure automatizza la maggior parte della migrazione. I passaggi generali sono:

I comandi CLI flex-migration automatizzano creazione e configurazione di app. I passaggi principali sono:

Il portale fornisce un percorso di migrazione manuale. I tuoi passaggi principali sono:

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Windows migrazione richiede passaggi manuali per la creazione e la configurazione dell'app. I tuoi passaggi principali sono:

Windows migrazione richiede passaggi manuali per la creazione e la configurazione dell'app. I tuoi passaggi principali sono:

Per avviare una migrazione interattiva che analizza la sottoscrizione e richiede di scegliere le app di cui eseguire la migrazione, usare questa richiesta:

migrate my linux function apps in azure from consumption to flex consumption

Copilot identifica le app a consumo Linux idonee, consente di scegliere quali eseguire la migrazione e quindi illustra la valutazione, la creazione, la configurazione e la distribuzione di app per ogni app. Continuare con la procedura di migrazione.

Se si vuole solo vedere quali app sono idonee senza avviare la migrazione, usare invece questa richiesta:

list my linux consumption apps eligible for flex consumption migration

Copilot restituisce un elenco di app idonee e non idonee, insieme ai motivi di eventuali incompatibilità. È quindi possibile eseguire la migrazione di un'app specifica usando il prompt in Avviare la migrazione per Linux.

Eseguire questo comando per vedere quali app a consumo Linux sono pronte per la migrazione:

az functionapp flex-migration list

Questo comando analizza automaticamente la sottoscrizione e restituisce due matrici:

• eligible_apps: applicazioni di tipo Consumption su Linux che possono essere migrate a Flex Consumption. Queste app sono compatibili con Flex Consumption.
• ineligible_apps: app di cui non è possibile eseguire la migrazione, insieme ai motivi specifici. Esaminare e risolvere i motivi di incompatibilità prima di continuare.

L'output include il nome dell'app, il gruppo di risorse, la posizione e lo stack di runtime per ogni app, oltre alle informazioni sullo stato di idoneità e sulla preparazione della migrazione.

1. Passare al Azure Resource Graph Explorer nel portale di Azure.

2. Copiare la query Kusto seguente, incollarla nella finestra della query e selezionare Esegui query:

   resources 
   | where type == 'microsoft.web/sites' 
   | where ['kind'] == 'functionapp,linux' 
   | where properties.sku == 'Dynamic'
   | extend siteProperties=todynamic(properties.siteProperties.properties) 
   | mv-expand siteProperties 
   | where siteProperties.name=='LinuxFxVersion' 
   | project name, location, resourceGroup, stack=tostring(siteProperties.value)
   

Questo comando crea una tabella con il nome dell'app, la posizione, il gruppo di risorse e lo stack di runtime per tutte le app a consumo in esecuzione in Linux nella sottoscrizione corrente.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il comando az graph query per elencare tutte le applicazioni di funzione eseguite nella sottoscrizione in un piano a consumo.

az graph query -q "resources | where subscriptionId == '$(az account show --query id -o tsv)' \
   | where type == 'microsoft.web/sites' | where ['kind'] == 'functionapp' | where properties.sku == 'Dynamic' \
   | project name, location, resourceGroup" \
   --query data --output table

Questo comando crea una tabella con il nome, la posizione e il gruppo di risorse dell'app per tutte le app a consumo in esecuzione in Windows nella sottoscrizione corrente.

Se non è già disponibile, viene richiesto di installare l'estensione resource-graph.

1. Passare al Azure Resource Graph Explorer nel portale di Azure.

2. Copiare la query Kusto seguente, incollarla nella finestra della query e selezionare Esegui query:

   resources 
   	| where type == 'microsoft.web/sites' 
   	| where ['kind'] == 'functionapp' 
   	| where properties.sku == 'Dynamic'
   	| project name, location, resourceGroup
   

Questo comando crea una tabella con il nome, la posizione e il gruppo di risorse dell'app per tutte le app a consumo in esecuzione in Windows nella sottoscrizione corrente.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare questo az functionapp list-flexconsumption-locations comando per elencare tutte le aree in cui è disponibile il piano Flex Consumption:

az functionapp list-flexconsumption-locations --query "sort_by(@, &name)[].{Region:name}" -o table

Questo comando genera una tabella delle regioni di Azure in cui è attualmente supportato il piano Flex Consumption.

Il processo di creazione per un'app per le funzioni nel portale di Azure filtra le aree attualmente non supportate dal piano Flex Consumption.

1. Nel portale di Azure selezionare Crea una risorsa nel menu a sinistra e selezionare App per le funzioni>Crea.

2. Selezionare Flex Consumption>Select e nella scheda Informazioni di base espandere Area.

3. Esaminare le aree del piano a consumo Flex supportate.

Assicurati che l'area in cui si trova l'app del Piano di consumo che vuoi migrare sia inclusa nell'elenco.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare questo comando az functionapp list-flexconsumption-runtimes per verificare il supporto del piano a consumo flex per la versione dello stack di linguaggio in un'area specifica:

az functionapp list-flexconsumption-runtimes --location <REGION> --runtime <LANGUAGE_STACK> --query '[].{version:version}' -o tsv

In questo esempio sostituire <REGION> con l'area corrente e <LANGUAGE_STACK> con uno dei valori seguenti:

Questo comando visualizza tutte le versioni dello stack di linguaggio specificato supportato dal piano Flex Consumption nell'area.

Il processo di creazione per un'app per le funzioni nel portale di Azure filtra le versioni dello stack di linguaggio non supportate dal piano Flex Consumption.

1. Nel portale di Azure selezionare Crea una risorsa nel menu a sinistra e selezionare App per le funzioni>Crea.

2. Selezionare Flex Consumption>Selezionare e nella scheda Informazioni di base selezionare lo stack di runtime e l'area del linguaggio.

3. Espandere Versione ed esaminare le versioni supportate dello stack di linguaggio nell'area scelta.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usa questo comando az functionapp deployment slot list per elencare eventuali slot di distribuzione definiti nella tua app delle funzioni:

az functionapp deployment slot list --name <APP_NAME> --resource-group <RESOURCE_GROUP> --output table

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> rispettivamente con il nome del gruppo di risorse e il nome dell'app. Se il comando restituisce una voce, l'app dispone di slot di distribuzione abilitati.

Per determinare se l'app per le funzioni dispone di slot di distribuzione abilitati:

1. Nel portale Azure cercare o passare in altro modo alla pagina dell'app per le funzioni.

2. Nel menu a sinistra selezionare Slot di distribuzione>.

3. Se vengono visualizzati slot elencati nella pagina Slot di distribuzione, l'app per le funzioni usa attualmente slot di distribuzione.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il az webapp config ssl list comando per elencare tutti i certificati TLS/SSL disponibili per l'app per le funzioni:

az webapp config ssl list --resource-group <RESOURCE_GROUP>  

In questo esempio sostituire <RESOURCE_GROUP> con il nome del gruppo di risorse. Se questo comando restituisce l'output, è probabile che l'app usi certificati.

Per determinare se l'app per le funzioni usa certificati TLS/SSL:

1. Nel portale Azure cercare o passare in altro modo alla pagina dell'app per le funzioni.

2. Nel menu a sinistra selezionare Impostazioni>Certificati.

3. Controllare le schede Certificati gestiti, Bring your own certificates (pfx) e Public key certificates (.cer) (Certificati pubblici ) per tutti i certificati installati.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare questo comando [az functionapp function list] per determinare se l'app dispone di trigger di archiviazione BLOB che non usano Griglia di eventi come origine:

az functionapp function list  --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
  --query "[?config.bindings[0].type=='blobTrigger' && config.bindings[0].source!='EventGrid'].{Function:name,TriggerType:config.bindings[0].type,Source:config.bindings[0].source}" \
  --output table

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> rispettivamente con il nome del gruppo di risorse e il nome dell'app. Se il comando restituisce righe, è presente almeno un trigger che utilizza il polling dei contenitori nella tua app per le funzioni.

Per determinare se l'app per le funzioni dispone di trigger di archiviazione BLOB che non usano Griglia di eventi come origine:

1. Cerca o passa in altro modo alla pagina della tua app Funzione nel portale Azure.

2. Nella scheda Panoramica della scheda Funzioni, cercare le funzioni con un tipo di triggerBlob.

3. Selezionare una funzione trigger blob e nel Code + Test selezionare Resource JSON.

4. Individuare la properties.config.bindings sezione della definizione della funzione. In questa sezione deve essere presente un oggetto bindings.type di blobTrigger. Se l'oggetto bindings non ha proprietà source o source ha un valore pari a LogsAndContainerScan, il trigger usa il polling del contenitore. Un trigger di origine di Griglia di eventi ha invece il valore source di EventGrid.

5. Ripetere i passaggi da 3 a 4 per le funzioni di trigger di archiviazione BLOB rimanenti nell'app.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il az functionapp config appsettings list comando per restituire un app_settings oggetto che contiene le impostazioni dell'app esistenti come JSON:

app_settings=$(az functionapp config appsettings list --name `<APP_NAME>` --resource-group `<RESOURCE_GROUP>`)
echo $app_settings

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app.

Per ottenere le impostazioni attuali dell'app delle funzioni:

1. Nel portale Azure, cercare o passare in altro modo alla pagina dell'applicazione di funzione.

2. Nel menu a sinistra espandere Impostazioni e selezionare Variabili di ambiente.

3. Nella scheda Impostazioni app selezionare Modifica avanzata e copiare e salvare il contenuto delle impostazioni dell'app JSON.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare questo script per ottenere le configurazioni pertinenti della tua applicazione esistente.

# Set the app and resource group names
appName=<APP_NAME>
rgName=<RESOURCE_GROUP>

echo "Getting commonly used site settings..."
az functionapp config show --name $appName --resource-group $rgName \
    --query "{http20Enabled:http20Enabled, httpsOnly:httpsOnly, minTlsVersion:minTlsVersion, \
    minTlsCipherSuite:minTlsCipherSuite, clientCertEnabled:clientCertEnabled, \
    clientCertMode:clientCertMode, clientCertExclusionPaths:clientCertExclusionPaths}"

echo "Checking for SCM basic publishing credentials policies..."
az resource show --resource-group $rgName --name scm --namespace Microsoft.Web \
    --resource-type basicPublishingCredentialsPolicies --parent sites/$appName --query properties

echo "Checking for the maximum scale-out limit configuration..."
az functionapp config appsettings list --name $appName --resource-group $rgName \
    --query "[?name=='WEBSITE_MAX_DYNAMIC_APPLICATION_SCALE_OUT'].value" -o tsv

echo "Checking for any file share mount configurations..."
az webapp config storage-account list --name $appName --resource-group $rgName

echo "Checking for any custom domains..."
az functionapp config hostname list --webapp-name $appName --resource-group $rgName --query "[?contains(name, 'azurewebsites.net')==\`false\`]" --output table

echo "Checking for any CORS settings..."
az functionapp cors show --name $appName --resource-group $rgName 

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> rispettivamente con il nome del gruppo di risorse e il nome dell'app. Se una delle impostazioni del sito o dei controlli restituisce valori non null, prendere nota di tali valori.

Per esaminare le configurazioni dell'applicazione pertinenti dell'app esistente:

1. Nel portale Azure cercare o passare in altro modo alla pagina dell'app per le funzioni.

2. Nel menu a sinistra espandere Impostazioni e selezionare Configurazione.

3. Nella scheda Impostazioni generali prendere nota delle impostazioni seguenti:

   • Credenziali di pubblicazione di SCM Basic Auth
   • Versione HTTP
   • Solo HTTPS
   • Versione minima di TLS in ingresso
   • Cifrario minimo TLS in ingresso
   • Certificati client in ingresso

4. Nella scheda Mapping percorso verificare se sono presenti montaggi di condivisione file esistenti richiesti dall'app. Se ci sono, prendi nota del nome dell'account di archiviazione, del nome della condivisione, del percorso di montaggio e del tipo di accesso per ogni condivisione montata.

5. In Impostazioni>Scalabilità orizzontale, se l'opzione Applica limite di scalabilità orizzontale è impostata su Sì, prendere nota del valore Limite massimo di scalabilità orizzontale.

6. In Impostazioni>Domini personalizzati prendere nota di qualsiasi nome di dominio diverso da *.azurewebsites.net, il tipo di associazione e le informazioni sul certificato SSL.

7. In CORS API> prendere nota delle origini CORS consentite in modo esplicito e di altre impostazioni CORS.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Questo script controlla sia l'identità gestita assegnata dal sistema che le identità gestite assegnate dall'utente associate all'app:

appName=<APP_NAME>
rgName=<RESOURCE_GROUP>

echo "Checking for a system-assigned managed identity..."
systemUserId=$(az functionapp identity show --name $appName --resource-group $rgName --query "principalId" -o tsv) 

if [[ -n "$systemUserId" ]]; then
echo "System-assigned identity principal ID: $systemUserId"
echo "Checking for role assignments..."
az role assignment list --assignee $systemUserId --all
else
  echo "No system-assigned identity found."
fi

echo "Checking for user-assigned managed identities..."
userIdentities=$(az functionapp identity show --name $appName --resource-group $rgName --query 'userAssignedIdentities' -o json)
if [[ "$userIdentities" != "{}" && "$userIdentities" != "null" ]]; then
  echo "$userIdentities" | jq -c 'to_entries[]' | while read -r identity; do
    echo "User-assigned identity name: $(echo "$identity" | jq -r '.key' | sed 's|.*/userAssignedIdentities/||')"
	echo "Checking for role assignments..."
    az role assignment list --assignee $(echo "$identity" | jq -r '.value.principalId') --all --output json
    echo
  done
else
  echo "No user-assigned identities found."
fi

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app. Prendere nota di tutte le identità e delle relative assegnazioni di ruolo.

1. Nel portale Azure, cerca o vai alla pagina della tua app per le funzioni.

2. Nel menu a sinistra espandere Impostazioni e selezionare Identità.

3. Controllare la scheda Assegnata dal sistema per verificare se l'identità gestita assegnata dal sistema è abilitata. Se abilitata, selezionare Azure assegnazioni di ruolo per visualizzare i ruoli assegnati a questa identità.

4. Controllare la scheda Assegnata dall'utente per verificare se sono assegnate identità gestite assegnate dall'utente. Prendere nota dei nomi delle identità assegnate agli utenti.

5. Per ogni identità gestita assegnata dall'utente, selezionare l'identità. Nella pagina Identità selezionare assegnazioni di ruoli di Azure.

6. Prendere nota di ogni assegnazione di ruolo concessa all'identità e determinare se l'app lo richiede.

Documentare tutte le identità e le relative assegnazioni di ruolo in modo da poter ricreare la stessa struttura di autorizzazioni per la nuova app Flex Consumption.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il az webapp auth show comando per verificare se l'autenticazione predefinita è configurata nell'app per le funzioni:

az webapp auth show --name <APP_NAME> --resource-group <RESOURCE_GROUP>

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app. Esaminare l'output per determinare se l'autenticazione è abilitata e quali provider di identità sono configurati.

Ricreare queste impostazioni nella nuova app dopo la migrazione in modo che i client possano mantenere l'accesso usando il provider preferito.

Per verificare se è configurata l'autenticazione client predefinita:

1. Nel portale Azure, cerca o vai alla pagina della Function App.

2. Nel menu a sinistra espandere Impostazioni e selezionare Autenticazione.

3. Se l'autenticazione predefinita è abilitata, tenere presente quali provider di identità client sono configurati. Si notino anche tutte le impostazioni avanzate, ad esempio l'archivio token, i reindirizzamenti esterni consentiti e i gruppi di destinatari dei token consentiti.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Questo az functionapp config access-restriction show comando restituisce un elenco di eventuali restrizioni di accesso basate su IP esistenti:

az functionapp config access-restriction show --name <APP_NAME> --resource-group <RESOURCE_GROUP>

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app.

1. Nel portale Azure, cerca o accedi in altro modo alla pagina della funzione app.

2. Nel menu a sinistra espandere Impostazioni e selezionare Rete.

3. Se viene visualizzato Abilitato senza restrizioni di accesso per l'accesso alla rete pubblica, non sono previste restrizioni di accesso in ingresso. In caso contrario, selezionare Restrizioni di accesso.

4. Documentare tutte le restrizioni di accesso basate su IP configurate.

Se hai utilizzato la richiesta di individuazione nella sezione Identificazione, la capacità ha già valutato, creato e configurato la nuova app Flex Consumption. È possibile ignorare questa sezione e continuare con la procedura di migrazione.

Se si conosce già l'app di cui eseguire la migrazione, usare questo prompt:

migrate my app <APP_NAME> to flex consumption

La competenza gestisce automaticamente la valutazione, la creazione dell'app e la az functionapp flex-migration start migrazione della configurazione, equivalente al comando e ai relativi passaggi di verifica.

Il az functionapp flex-migration start comando raccoglie la configurazione dell'app e crea una nuova app Flex Consumption con le stesse impostazioni.

az functionapp flex-migration start \
    --source-name <SOURCE_APP_NAME> \
    --source-resource-group <SOURCE_RESOURCE_GROUP> \
    --name <NEW_APP_NAME> \
    --resource-group <RESOURCE_GROUP>

In questo esempio sostituire questi segnaposto con i valori per lo scenario:

Il az functionapp flex-migration start comando esegue queste attività di base:

• Valuta l'app di origine per la compatibilità con il piano di hosting Flex Consumption.
• Crea un'applicazione di funzioni nel piano Flex Consumption.
• Esegue la migrazione della maggior parte delle configurazioni, incluse le impostazioni dell'app, le assegnazioni di identità, i montaggi di archiviazione, le impostazioni CORS, i domini personalizzati e le restrizioni di accesso.

Il comando di migrazione supporta diverse opzioni per personalizzare la migrazione:

Per le opzioni di comando complete, usare az functionapp flex-migration start --help.

Il portale di Azure non fornisce un comando di migrazione automatica per le app Linux. Usa le schede interfaccia della riga di comando di Azure o GitHub Copilot per l'esperienza di migrazione Linux consigliata.

La funzionalità di migrazione di Copilot tenta di scaricare e ridistribuire il vostro progetto di codice esistente nella nuova app. In caso di esito negativo, ti guida invece nell'ottenere e rilasciare il pacchetto di codice come parte del flusso di lavoro di migrazione. È possibile ignorare questa sezione e continuare a Passaggi di migrazione.

1. Usare il az functionapp config appsettings list comando per ottenere l'impostazione dell'app WEBSITE_RUN_FROM_PACKAGE , se presente:

   az functionapp config appsettings list --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
       --query "[?name=='WEBSITE_RUN_FROM_PACKAGE'].value" -o tsv
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app. Se questo comando restituisce un URL, è possibile scaricare il file del pacchetto di distribuzione da tale percorso remoto e passare alla sezione successiva.

2. Se il WEBSITE_RUN_FROM_PACKAGE valore è 1 o vuoto, usare questo script per ottenere il pacchetto di distribuzione per l'app esistente:

   appName=<APP_NAME>
   rgName=<RESOURCE_GROUP>
   
   echo "Getting the storage account connection string from app settings..."
   storageConnection=$(az functionapp config appsettings list --name $appName --resource-group $rgName \
            --query "[?name=='AzureWebJobsStorage'].value" -o tsv)
   
   echo "Getting the package name..."
   packageName=$(az storage blob list --connection-string $storageConnection --container-name scm-releases \
   --query "[0].name" -o tsv)
   
   echo "Download the package? $packageName? (Y to proceed, any other key to exit)"
   read -r answer
   if [[ "$answer" == "Y" || "$answer" == "y" ]]; then
      echo "Proceeding with download..."
      az storage blob download --connection-string $storageConnection --container-name scm-releases \
   --name $packageName --file $packageName
   else
      echo "Exiting script."
      exit 0
   fi
   

   Anche in questo caso, sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome e il nome dell'app del gruppo di risorse. Il pacchetto .zip file viene scaricato nella directory da cui è stato eseguito il comando.

1. Nel portale Azure cercare o passare in altro modo alla pagina dell'app per le funzioni.

2. Nel menu a sinistra espandere Impostazioni Variabili>di ambiente e verificare se esiste un'impostazione denominata WEBSITE_RUN_FROM_PACKAGE .

3. Se WEBSITE_RUN_FROM_PACKAGE esiste, assicurarsi di impostarlo su un valore di 1 o un URL. Se impostato su un URL, tale URL è il percorso del file del pacchetto per il contenuto dell'app. Scaricare il file .zip da tale percorso URL di cui si è proprietari.

4. Se l'impostazione WEBSITE_RUN_FROM_PACKAGE non esiste o è impostata su 1, è necessario scaricare il pacchetto dall'account di archiviazione specifico, che dipende dal fatto che si sia in esecuzione in Linux o Windows.

5. Ottenere il nome dell'account di archiviazione dall'impostazione dell'applicazione AzureWebJobsStorage o AzureWebJobsStorage__accountName . Per un stringa di connessione, l'AccountName è il nome dell'account di archiviazione.

6. Nel portale cercare il nome dell'account di archiviazione.

7. Nella pagina account di archiviazione individuare il pacchetto di distribuzione e scaricarlo.

8. Espandi contenitori>di archiviazione dati e seleziona scm_releases. Scegliere il file denominato scm-latest-<APP_NAME>.zip e selezionare Scarica.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

1. Usare il az functionapp config appsettings list comando per ottenere l'impostazione dell'app WEBSITE_RUN_FROM_PACKAGE , se presente:

   az functionapp config appsettings list --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
       --query "[?name=='WEBSITE_RUN_FROM_PACKAGE'].value" -o tsv
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome del gruppo di risorse e il nome dell'app. Se questo comando restituisce un URL, è possibile scaricare il file del pacchetto di distribuzione da tale percorso remoto e passare alla sezione successiva.

2. Se il WEBSITE_RUN_FROM_PACKAGE valore è 1 o vuoto, usare questo script per ottenere il pacchetto di distribuzione per l'app esistente:

   appName=<APP_NAME>
   rgName=<RESOURCE_GROUP>
   
   echo "Getting the storage account connection string and file share from app settings..."
   json=$(az functionapp config appsettings list --name $appName --resource-group $rgName \
       --query "[?name=='WEBSITE_CONTENTAZUREFILECONNECTIONSTRING' || name=='WEBSITE_CONTENTSHARE'].value" -o json)
   
   storageConnection=$(echo "$json" | jq -r '.[0]')
   fileShare=$(echo "$json" | jq -r '.[1]')
   
   echo "Getting the package name..."
   packageName=$(az storage file list --share-name $fileShare --connection-string $storageConnection \
     --path "data/SitePackages" --query "[?ends_with(name, '.zip')] | sort_by(@, &properties.lastModified)[-1].name" \
     -o tsv) 
   
   echo "Download the package? $packageName? (Y to proceed, any other key to exit)"
   read -r answer
   if [[ "$answer" == "Y" || "$answer" == "y" ]]; then
       echo "Proceeding with download..."
       az storage file download --connection-string $storageConnection --share-name $fileShare \
   	--path "data/SitePackages/$packageName"
   else
       echo "Exiting script."
       exit 0
   fi
   

   Anche in questo caso, sostituire <RESOURCE_GROUP> e <APP_NAME> con il nome e il nome dell'app del gruppo di risorse. Il pacchetto .zip file viene scaricato nella directory da cui è stato eseguito il comando.

1. Nel portale Azure, cerca o vai alla pagina della Function App.

2. Nel menu a sinistra espandere Impostazioni Variabili>di ambiente e verificare se esiste un'impostazione denominata WEBSITE_RUN_FROM_PACKAGE .

3. Se WEBSITE_RUN_FROM_PACKAGE esiste, assicurarsi di impostarlo su un valore di 1 o un URL. Se impostato su un URL, tale URL è il percorso del file del pacchetto per il contenuto dell'app. Scaricare il file .zip da tale percorso URL di cui si è proprietari.

4. Se l'impostazione WEBSITE_RUN_FROM_PACKAGE non esiste o è impostata su 1, è necessario scaricare il pacchetto dall'account di archiviazione specifico, che dipende dal fatto che si sia in esecuzione in Linux o Windows.

5. Ottenere il nome dell'account di archiviazione dall'impostazione WEBSITE_CONTENTAZUREFILECONNECTIONSTRING , dove AccountName è il nome dell'account di archiviazione. Prendere nota del valore WEBSITE_CONTENTSHARE, ovvero il nome della condivisione di file.

6. Nel portale cercare il nome dell'account di archiviazione.

7. Nella pagina account di archiviazione individuare il pacchetto di distribuzione e scaricarlo.

8. Espandere Archiviazione dati>Condivisione dati, selezionare il nome della condivisione da WEBSITE_CONTENTSHARE e passare alla sottocartella data\SitePackages. Scegliere il file di .zip più recente e selezionare Scarica.

La funzionalità di migrazione di Copilot verifica automaticamente la nuova app nel contesto della migrazione. Se hai avviato la migrazione utilizzando un prompt di Copilot in Avvia la migrazione per Linux, la funzione ha già verificato che l'app sia stata creata e configurata correttamente. È possibile ignorare questa sezione e continuare a Configurare l'autenticazione predefinita.

1. Verificare che la nuova app esista ed è in esecuzione:

   az functionapp show --name <NEW_APP_NAME> --resource-group <RESOURCE_GROUP> \
        --query "{name:name, kind:kind, sku:properties.sku}" --output table
   

2. Esaminare le impostazioni dell'app di cui è stata eseguita la migrazione:

   az functionapp config appsettings list --name <NEW_APP_NAME> --resource-group <RESOURCE_GROUP> \
        --output table
   

   Confrontare queste impostazioni con l'app di origine per assicurarsi che le configurazioni critiche vengano trasferite.

3. Controllare la configurazione dell'identità gestita:

   az functionapp identity show --name <NEW_APP_NAME> --resource-group <RESOURCE_GROUP>
   

4. Verificare che sia stata eseguita la migrazione di domini personalizzati:

   az functionapp config hostname list --webapp-name <NEW_APP_NAME> --resource-group <RESOURCE_GROUP> \
        --output table
   

1. Nel portale Azure, cerca la tua nuova funzione app per nome.

2. Nella pagina Panoramica dell'app verificare:

   • Lo stato viene visualizzato come Running
   • Il tipo di piano viene visualizzato come Flex Consumption
   • Il gruppo di risorse e la località corrispondono alle aspettative

3. Nel menu a sinistra, espandere ImpostazioniVariabili di ambiente ed esaminare la scheda Impostazioni dell'app per verificare che le impostazioni dell'applicazione siano migrate correttamente.

4. Controllare Impostazioni>Identità per verificare che le identità gestite siano configurate come previsto.

5. Se applicabile, selezionare Impostazioni>Domini personalizzati per confermare eventuali mapping di dominio personalizzati.

6. Vedere Impostazioni>Rete per verificare le restrizioni di accesso se esistono nell'app di origine.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Eseguire questo script che esegue queste attività:

1. Ottiene le impostazioni dell'app dall'app precedente, ignorando le impostazioni che non si applicano in un piano a consumo Flex o che esistono già nella nuova app.
2. Scrive le impostazioni raccolte localmente in un file temporaneo.
3. Applica le impostazioni dal file alla nuova app.
4. Elimina il file temporaneo.

sourceAppName=<SOURCE_APP_NAME>
destAppName=<DESTINATION_APP_NAME>
rgName=<RESOURCE_GROUP>

echo "Getting app settings from the old app..."
app_settings=$(az functionapp config appsettings list --name $sourceAppName --resource-group $rgName)

# Filter out settings that don't apply to Flex Consumption apps or that will already have been created
filtered_settings=$(echo "$app_settings" | jq 'map(select(
  (.name | ascii_downcase) != "website_use_placeholder_dotnetisolated" and
  (.name | ascii_downcase | startswith("azurewebjobsstorage") | not) and
  (.name | ascii_downcase) != "website_mount_enabled" and
  (.name | ascii_downcase) != "enable_oryx_build" and
  (.name | ascii_downcase) != "functions_extension_version" and
  (.name | ascii_downcase) != "functions_worker_runtime" and
  (.name | ascii_downcase) != "functions_worker_runtime_version" and
  (.name | ascii_downcase) != "functions_max_http_concurrency" and
  (.name | ascii_downcase) != "functions_worker_process_count" and
  (.name | ascii_downcase) != "functions_worker_dynamic_concurrency_enabled" and
  (.name | ascii_downcase) != "scm_do_build_during_deployment" and
  (.name | ascii_downcase) != "website_contentazurefileconnectionstring" and
  (.name | ascii_downcase) != "website_contentovervnet" and
  (.name | ascii_downcase) != "website_contentshare" and
  (.name | ascii_downcase) != "website_dns_server" and
  (.name | ascii_downcase) != "website_max_dynamic_application_scale_out" and
  (.name | ascii_downcase) != "website_node_default_version" and
  (.name | ascii_downcase) != "website_run_from_package" and
  (.name | ascii_downcase) != "website_skip_contentshare_validation" and
  (.name | ascii_downcase) != "website_vnet_route_all" and
  (.name | ascii_downcase) != "applicationinsights_connection_string"
))')

echo "Settings to migrate..."
echo "$filtered_settings"

echo "Writing settings to a local a local file (app_settings_filtered.json)..."
echo "$filtered_settings" > app_settings_filtered.json

echo "Applying settings to the new app..."
output=$(az functionapp config appsettings set --name $destAppName --resource-group $rgName --settings @app_settings_filtered.json)

echo "Deleting the temporary settings file..."
rm -rf app_settings_filtered.json  

echo "Current app settings in the new app..."
az functionapp config appsettings list --name $destAppName --resource-group $rgName 

In questo esempio sostituire <RESOURCE_GROUP>, <SOURCE_APP_NAME>e <DEST_APP_NAME> rispettivamente con il nome del gruppo di risorse e i nomi delle app precedenti e nuovi. Questo script presuppone che entrambe le app si trovino nello stesso gruppo di risorse.

Per trasferire le impostazioni:

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni>Variabili di ambiente. Nella scheda Impostazioni app selezionare + Aggiungi.

3. Digitare o incollare sia l'impostazione Nome che Valore, quindi selezionare Applica.

4. Ripetere il passaggio precedente per ogni impostazione nell'app precedente che è necessario ricreare nella nuova app. Se nella nuova app esiste già un'impostazione, ignorarla. Ignora anche eventuali impostazioni deprecate nel piano Flex Consumption.

5. Dopo aver aggiunto tutte le impostazioni pertinenti, selezionare Applica>salva.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

In questo script, impostare il valore per ogni set di configurazione nell'app originale e commentare i comandi per qualsiasi configurazione non impostata (null):

appName=<APP_NAME>
rgName=<RESOURCE_GROUP>
http20Setting=<YOUR_HTTP_20_SETTING>
minTlsVersion=<YOUR_TLS_VERSION>
minTlsCipher=<YOUR_TLS_CIPHER>
httpsOnly=<YOUR_HTTPS_ONLY_SETTING>
certEnabled=<CLIENT_CERT_ENABLED>
certMode=<YOUR_CLIENT_CERT_MODE>
certExPaths=<CERT_EXCLUSION_PATHS>
scmAllowBasicAuth=<ALLOW_SCM_BASIC_AUTH>

# Apply HTTP version and minimum TLS settings
az functionapp config set --name $appName --resource-group $rgName --http20-enabled $http20Setting  
az functionapp config set --name $appName --resource-group $rgName --min-tls-version $minTlsVersion

# Apply the HTTPS-only setting
az functionapp update --name $appName --resource-group $rgName --set HttpsOnly=$httpsOnly

# Apply incoming client cert settings
az functionapp update --name $appName --resource-group $rgName --set clientCertEnabled=$certEnabled
az functionapp update --name $appName --resource-group $rgName --set clientCertMode=$certMode
az functionapp update --name $appName --resource-group $rgName --set clientCertExclusionPaths=$certExPaths

# Apply the TLS cipher suite setting
az functionapp update --name $appName --resource-group $rgName --set minTlsCipherSuite=$minTlsCipher

# Apply the allow scm basic auth configuration
az resource update --resource-group $rgName --name scm --namespace Microsoft.Web --resource-type basicPublishingCredentialsPolicies \
	--parent sites/$appName --set properties.allow=$scmAllowBasicAuth

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il gruppo di risorse e i nomi delle app per le funzioni. Sostituire anche i segnaposto nelle definizioni delle variabili per le impostazioni esistenti da ricreare nella nuova app e commentare eventuali impostazioni null.

1. Nel portale Azure, cerca o accedi alla pagina della nuova app.

2. Nel menu a sinistra espandere Configurazione delleimpostazioni e nella scheda > generali aggiornare queste impostazioni in modo che corrispondano a quanto documentato dall'app del piano a consumo originale:

   • Credenziali di pubblicazione di SCM Basic Auth
   • Versione HTTP
   • Solo HTTPS
   • Versione minima di TLS in ingresso e crittografia
   • Impostazioni certificato client

3. Selezionare Salva per applicare le modifiche alla configurazione.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il comando az functionapp scale config set per impostare la scalabilità massima verso l'esterno.

az functionapp scale config set --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
    --maximum-instance-count <MAX_SCALE_SETTING>

In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il gruppo di risorse e i nomi delle app per le funzioni. Sostituire <MAX_SCALE_SETTING> con il valore di scala massimo che si desidera impostare.

Per configurare la scalabilità e la concorrenza nella nuova app:

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni>Scalabilità e concorrenza. Per Numero massimo di istanze, impostare un valore massimo per la scala dell'app.

3. Selezionare questa opzione Save per applicare le modifiche.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

1. Usare il az functionapp config hostname add comando per riassociare i mapping di dominio personalizzati all'app:

   az functionapp config hostname add --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
       --hostname <CUSTOM_DOMAIN>
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il gruppo di risorse e i nomi delle app per le funzioni. Sostituire <CUSTOM_DOMAIN> con il nome di dominio personalizzato.

2. Usare il az functionapp cors add comando per sostituire le impostazioni CORS:

   az functionapp cors add --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
       --allowed-origins <ALLOWED_ORIGIN_1> <ALLOWED_ORIGIN_2> <ALLOWED_ORIGIN_N>
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il gruppo di risorse e i nomi delle app per le funzioni. Sostituire <ALLOWED_ORIGIN_*> con le origini consentite.

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni Domini>personalizzati, selezionare + Aggiungi dominio personalizzato, configurare il dominio personalizzato, selezionare Convalida e quindi selezionare Aggiungi.

3. Ripetere il passaggio precedente per aggiungere altri domini personalizzati.

4. Nel menu a sinistra espandere CORS API>, aggiungere una o più origini consentite e selezionare Salva.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

1. Usare il az functionapp identity assign comando per abilitare l'identità gestita assegnata dal sistema nella nuova app:

   az functionapp identity assign --name <APP_NAME> --resource-group <RESOURCE_GROUP>
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> con il gruppo di risorse e i nomi delle app per le funzioni.

2. Usare questo script per ottenere l'ID principale dell'identità assegnata dal sistema e aggiungerlo ai ruoli richiesti.

   # Get the principal ID of the system identity
   principalId=$(az functionapp identity show --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
       --query principalId -o tsv)
   
   # Assign a role in a specific resource (scope) to the system identity
   az role assignment create --assignee $principalId --role "<ROLE_NAME>" --scope "<RESOURCE_ID>"
   

   In questo esempio sostituire <RESOURCE_GROUP> e <APP_NAME> rispettivamente con il gruppo di risorse e i nomi delle app per le funzioni. Sostituire <ROLE_NAME> e <RESOURCE_ID> con il nome del ruolo e la risorsa specifica acquisita dall'app originale.

3. Ripetere i comandi precedenti per ogni ruolo richiesto dalla nuova app.

Usare questo script per ottenere l'ID di un'identità gestita assegnata dall'utente esistente e associarla alla nuova app:

appName=<APP_NAME>
rgName=<RESOURCE_GROUP>
userName=<USER_IDENTITY_NAME>

userId=$(az identity show --name $userName --resource-group $rgName --query 'id' -o tsv)
az functionapp identity assign --name $appName --resource-group $rgName --identities $userId

Ripetere questo script per ogni ruolo richiesto dalla nuova app.

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni>Identità e nella scheda Assegnata dal sistema impostare Stato su Sì.

3. Selezionare assegnazioni di ruolo di Azure nel riquadro sinistro.

4. Selezionare + Aggiungi assegnazione di ruolo e impostare queste proprietà di assegnazione per un ruolo documentato nell'app originale:

   Proprietà	Descrizione
   Ambito	Tipo di risorsa a cui si accede.
   Abbonamento	Abbonamento della risorsa.
   risorsa	Risorsa specifica all'interno dell'ambito selezionato.
   Ruolo	Cercare e selezionare il ruolo assegnato.

5. Selezionare Salva per aggiungere l'ambito. Per aggiungere altri ruoli, ripetere il passaggio precedente per ogni ruolo documentato richiesto dalla nuova app.

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni>Identità e nella scheda Assegnata dall'utente selezionare + Aggiungi.

3. Selezionare un'identità esistente e quindi selezionare Aggiungi.

4. Selezionare l'identità appena aggiunta e selezionare Assegnazioni dei ruoli di Azure nel riquadro sinistro.

5. Selezionare + Aggiungi assegnazione di ruolo e impostare queste proprietà di assegnazione per un ruolo documentato nell'app originale:

   Proprietà	Descrizione
   Ambito	Tipo di risorsa a cui si accede.
   Abbonamento	Abbonamento della risorsa.
   risorsa	Risorsa specifica all'interno dell'ambito selezionato.
   Ruolo	Cercare e selezionare il ruolo assegnato.

6. Selezionare Salva per aggiungere l'ambito. Per aggiungere altri ruoli, ripetere il passaggio precedente per ogni ruolo documentato richiesto dalla nuova app.

La competenza di migrazione GitHub Copilot è attualmente supportata solo durante la migrazione delle app Linux. Per eseguire la migrazione di un'app a consumo di Windows, usare le schede interfaccia della riga di comando di Azure o Azure portal.

Usare il az functionapp config access-restriction add comando per ogni restrizione di accesso IP che si vuole replicare nella nuova app:

az functionapp config access-restriction add --name <APP_NAME> --resource-group <RESOURCE_GROUP> \
  --rule-name <RULE_NAME> --action Deny --ip-address <IP_ADDRESS> --priority <PRIORITY>

In questo esempio sostituire questi segnaposto con i valori dell'app originale:

Eseguire questo comando per ogni restrizione IP documentata dall'app originale.

Per aggiungere restrizioni di rete basate su IP:

1. Nel portale Azure, cerca o vai alla pagina della tua nuova app.

2. Nel menu a sinistra espandere Impostazioni>rete e selezionare il collegamento accanto ad Accesso alla rete pubblica.

3. Nella pagina Restrizioni di accesso in Accesso al sito e regole selezionare + Aggiungi e immettere queste impostazioni per una restrizione IP specifica:

   Impostazione	Valore
   Nome	Nome amichevole per la regola IP.
   azione	Nega
   Priorità	Priorità per l'esclusione.
   Tipo	Selezionare IPv4 o IPv6.
   Blocco indirizzi IP	Indirizzi IP da escludere.

4. Selezionare Aggiungi regola e ripetere il passaggio precedente per ogni restrizione di accesso documentata.

5. Dopo aver immesso tutte le restrizioni IP dall'app originale, selezionare Salva.