Avvio rapido: Distribuire un'app Web Python (Django, Flask o FastAPI) nel servizio app di Azure
Articolo
Nota
A partire dal 1° giugno 2024, tutte le app del servizio app appena create avranno la possibilità di generare un nome host predefinito univoco usando la convenzione di denominazione <app-name>-<random-hash>.<region>.azurewebsites.net. I nomi delle app esistenti rimarranno invariati.
In questo avvio rapido si distribuisce un'app Web Python (Django, Flask o FastAPI) nel Servizio app di Azure. Il Servizio app di Azure è un servizio di hosting Web completamente gestito che supporta app Python ospitate in un ambiente server Linux.
Per completare l'esercitazione introduttiva, sono necessari gli elementi seguenti:
Questo articolo contiene istruzioni aggiornate per la distribuzione di un'app Web Python con il Servizio app di Azure. Python non è più supportato in Windows.
Applicazione di esempio
Questo avvio rapido può essere completato usando Flask, Django o FastAPI. Viene fornita un'applicazione di esempio in ogni framework che facilita l’uso di questo avvio rapido. Scaricare o clonare l'applicazione di esempio nella propria workstation locale.
Per ospitare l'applicazione in Azure, è necessario creare un'app Web del servizio app di Azure in Azure. È possibile creare un'app Web usando l'interfaccia della riga di comando di Azure, VS Code, il pacchetto di estensione Strumenti di Azure o il portale di Azure.
L'interfaccia della riga di comando di Azure include un comando az webapp up che creerà le risorse necessarie e distribuirà l'applicazione in un unico passaggio.
Se necessario, accedere ad Azure tramite az login.
az login
Creare l'app Web e altre risorse, quindi distribuire il codice in Azure usando az webapp up.
az webapp up --runtime PYTHON:3.9 --sku B1 --logs
Il parametro --runtime specifica la versione dell'app Python in esecuzione. Questo esempio usa Python 3.9. Per elencare tutti gli snapshot disponibili, usare il comando az webapp list-runtimes --os linux --output table.
Il parametro --sku definisce le dimensioni (CPU, memoria) e il costo del piano di servizio app. Questo esempio usa il piano di servizio B1 (Basic), che comporta un costo ridotto nella sottoscrizione di Azure. Per un elenco completo dei piani del Servizio app, visualizzare la pagina Prezzi del Servizio app.
Il flag --logs configura la registrazione predefinita necessaria per abilitare la visualizzazione del flusso di log subito dopo l'avvio dell'app Web.
Facoltativamente, è possibile specificare un nome con l'argomento --name <app-name>. Se non se ne fornisce uno, il nome viene generato automaticamente.
Facoltativamente, è possibile includere l'argomento --location <location-name>, dove <location_name> è un'area di Azure disponibile. Per recuperare un elenco di aree consentite per l'account Azure, è possibile eseguire il comando az appservice list-locations.
Il completamento del comando può richiedere alcuni minuti. Mentre il comando è in esecuzione, fornisce messaggi sulla creazione del gruppo di risorse, sul piano del Servizio app e sulla risorsa dell'app, sulla configurazione della registrazione e sulla distribuzione ZIP. Viene quindi visualizzato il messaggio che indica che è possibile avviare l'app all'indirizzo http://<nome-app>.azurewebsites.net, ovvero l'URL dell'app in Azure.
The webapp '<app-name>' doesn't exist
Creating Resource group '<group-name>' ...
Resource group creation complete
Creating AppServicePlan '<app-service-plan-name>' ...
Creating webapp '<app-name>' ...
Configuring default logging for the app, if not already enabled
Creating zip with contents of dir /home/cephas/myExpressApp ...
Getting scm site credentials for zip deployment
Starting zip deployment. This operation can take a while to complete ...
Deployment endpoint responded with status code 202
You can launch the app at http://<app-name>.azurewebsites.net
{
"URL": "http://<app-name>.azurewebsites.net",
"appserviceplan": "<app-service-plan-name>",
"location": "centralus",
"name": "<app-name>",
"os": "<os-type>",
"resourcegroup": "<group-name>",
"runtime_version": "python|3.9",
"runtime_version_detected": "0.0",
"sku": "FREE",
"src_path": "<your-folder-location>"
}
Nota
Il comando az webapp up esegue le azioni seguenti:
Memorizzare nella cache i parametri in locale nel file .azure/config in modo che non sia necessario specificarli di nuovo durante la distribuzione successiva con az webapp up o altri comandi az webapp della cartella del progetto. I valori memorizzati nella cache vengono usati automaticamente per impostazione predefinita.
Individuare l'icona di Azure nella barra degli strumenti a sinistra. Selezionarla per visualizzare l'estensione Strumenti di Azure per VS Code.
Se non viene visualizzata l'icona Strumenti di Azure, accertarsi che sia installata l'estensione Strumenti di Azure per VS Code.
Nell’estensione Strumenti di Azure per VS Code:
Trovare la sezione RISORSE e selezionare la propria sottoscrizione.
Selezionare + (Crea risorsa...)
Scegliere l'opzione Crea app Web del Servizio app....
Immettere il nome msdocs-python-webapp-quickstart-XYZ per questa app Web, in cui XYZ è costituito da tre caratteri univoci.
Quando viene distribuito, questo nome viene usato come nome dell'app nel formato https://<app-name>.azurewebsites.net.
Selezionare lo stack di runtime per l'applicazione. In questo esempio, selezionare Python 3.9.
Selezionare il piano del Servizio app (piano tariffario) per questa app Web. Il piano del Servizio app controlla il numero di risorse (CPU/memoria) disponibili per l'app e l’importo che si paga.
Per questo esempio, selezionare il piano tariffario Basic (B1). Questo piano comporta un piccolo addebito per la sottoscrizione di Azure, ma è consigliato per ottenere prestazioni migliori rispetto al livello Free (F1).
Selezionare il pulsante Distribuisci nella notifica "Nuova app Web creata".
Selezionare la cartella di avvio rapido in cui si sta lavorando come cartella da distribuire.
Rispondere Sì per aggiornare la configurazione per la generazione e migliorare le prestazioni della distribuzione.
Al termine della distribuzione, verrà visualizzata una notifica nell'angolo inferiore destro di VS Code. È possibile usare questa notifica per passare all'app Web.
Per creare risorse del Servizio app di Azure, accedere al portale di Azure e seguire questa procedura.
Istruzioni
Schermata
Nel portale di Azure:
Nella barra di ricerca nella parte superiore del portale di Azure, immettere servizi app.
Nel menu che viene visualizzato sotto la barra di ricerca, selezionare l'elemento etichettato Servizi app sotto l'intestazione Servizi.
Nella pagina Servizi app, selezionare + Crea, quindi selezionare + App Web dal menu a discesa.
Nella pagina Crea app Web, generare il modulo come indicato di seguito.
Gruppo di risorse → Selezionare Crea nuovo e usare un nome msdocs-python-webapp-quickstart.
Nome → msdocs-python-webapp-quickstart-XYZ, dove XYZ è costituito da tre caratteri casuali. Il nome deve essere univoco in Azure
Stack di runtime → Python 3.9.
Area → Qualunque area di Azure nelle vicinanze.
Piano del Servizio app → in Piano tariffario, selezionare Esplora piani tariffari per selezionare un piano del Servizio app differente.
Il piano di servizio app controlla il numero di risorse (CPU/memoria) disponibili per l'app e il costo di tali risorse.
Per questo esempio, in Sviluppo/Test selezionare il piano Basic B1. Il piano Basic B1 comporta un piccolo addebito per l’account di Azure, ma è consigliato per ottenere prestazioni migliori rispetto al piano Free F1.
Al termine, scegliere Seleziona per applicare le modifiche.
Nella pagina principale Crea app Web, selezionare Rivedi + Crea nella parte inferiore dello schermo.
Viene visualizzata la pagina Rivedi. Selezionare Crea per creare il Servizio app.
Il servizio app di Azure supporta più metodi per distribuire il codice dell'applicazione in Azure, tra cui GitHub Actions e tutti i principali strumenti di integrazione continua e recapito continuo (CI/CD). Questo articolo è incentrato su come distribuire il codice da una workstation locale in Azure.
Poiché il comando az webapp up ha creato le risorse necessarie e ha distribuito l'applicazione in un singolo passaggio, è possibile procedere al passaggio successivo.
Poiché nel passaggio precedente sono state create le risorse necessarie ed è stata distribuita l'applicazione in un singolo passaggio, è possibile procedere al passaggio successivo.
È possibile distribuire il codice dell'applicazione da un repository Git locale ad Azure configurando un repository Git remoto nel repository locale che punta al repository in cui eseguire il push del codice. È possibile recuperare l'URL del repository remoto e le credenziali Git necessarie per la configurazione usando il portale di Azure o l'interfaccia della riga di comando di Azure.
Immettere il nome del Servizio app nella casella di ricerca nella parte superiore dello schermo.
Nell'intestazione Risorse, selezionare il Servizio app per passare al Servizio app.
Nella pagina del Servizio app:
Selezionare Centro distribuzione dal menu a sinistra dello schermo.
Selezionare Git locale nell'elenco a discesa con l’etichetta Origine.
Seleziona Salva.
Dopo il salvataggio, la pagina verrà aggiornata e visualizzerà l'indirizzo del repository Git remoto.
Copiare il valore dell’Uri Git Clone perché questo valore verrà usato per configurare un repository Git remoto in un passaggio successivo.
Nella pagina Centro distribuzione:
Passare alla scheda Credenziali Git/FTPS locali.
Individuare il nome utente e la password di Git locale sotto le credenziali Ambito applicazione.
Tenere aperta questa schermata in modo da poter copiare momentaneamente queste credenziali quando si distribuisce il codice nel repository remoto. Copiare il nome utente Git locale, che inizia con $, ad esempio $msdocs-python-webapp-quickstart-123.
Quando si esegue il push del codice nel repository Git remoto per la prima volta, queste credenziali sono necessarie per l'autenticazione nel repository remoto.
Successivamente, nella directory radice dell'applicazione, configurare un repository Git remoto che punta ad Azure usando l'URL Git del repository remoto di Azure ottenuto in un passaggio precedente.
git remote add azure <git-deployment-url>
A questo punto, è possibile eseguire il push dal codice dal repository Git locale ad Azure usando il repository Git remoto appena configurato. Il ramo di distribuzione predefinito per il servizio app è master, ma molti repository Git stanno passando da master a main. È possibile specificare il mapping dal nome del ramo locale al nome del ramo remoto nel push (come illustrato di seguito) o configurare l'impostazione dell’app DEPLOYMENT_BRANCH.
git push azure main:master
La prima volta che si esegue il push del codice in Azure, Git chiederà le credenziali di distribuzione di Azure ottenute nel passaggio precedente. Git, quindi, memorizza nella cache queste credenziali in modo che non sia necessario immetterle nuovamente nelle distribuzioni successive.
Prima di tutto, configurare l'origine della distribuzione per l'app Web come Git locale usando il comando az webapp deployment source. Questo comando restituirà l'URL del repository Git remoto in cui verrà eseguito il push del codice. Creare una copia di questo valore, che sarà necessario in un passaggio successivo.
# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'
az webapp deployment source config-local-git \
--name $APP_SERVICE_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--output tsv
# Change these values to the ones used to create the App Service.
$RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
$APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'
az webapp deployment source config-local-git `
--name $APP_SERVICE_NAME `
--resource-group $RESOURCE_GROUP_NAME `
--output tsv
Recuperare le credenziali di distribuzione per l'applicazione. Questi elementi saranno necessari per l'autenticazione di Git in Azure quando si esegue il push del codice in Azure in un passaggio successivo.
Successivamente, nella directory radice dell'applicazione, configurare un repository Git remoto che punta ad Azure usando l'URL Git del repository remoto di Azure ottenuto in un passaggio precedente.
git remote add azure <git-deployment-url>
A questo punto, è possibile eseguire il push dal codice dal repository Git locale ad Azure usando il repository Git remoto appena configurato. Il ramo di distribuzione predefinito per il servizio app è master, ma molti repository Git stanno passando da master a main. È possibile specificare il mapping dal nome del ramo locale al nome del ramo remoto nel push (come illustrato di seguito) o configurare l'impostazione dell’app DEPLOYMENT_BRANCH.
git push azure main:master
La prima volta che si esegue il push del codice in Azure, Git chiederà le credenziali di distribuzione di Azure ottenute in un passaggio precedente. Git, quindi, memorizza nella cache queste credenziali in modo che non sia necessario immetterle nuovamente nelle distribuzioni successive.
Le applicazioni possono essere distribuite in Azure creando e caricando un file ZIP del codice dell'applicazione in Azure. I file ZIP possono essere caricati in Azure usando l'interfaccia della riga di comando di Azure o un client HTTP come cURL.
Abilitare l’automazione della generazione
Quando si distribuisce un file ZIP del codice Python, è necessario impostare un flag per abilitare l'automazione della generazione di Azure. L'automazione della generazione installerà tutti i requisiti necessari e creerà il pacchetto dell'applicazione da eseguire in Azure.
L'automazione della generazione in Azure è abilitata definendo l'impostazione dell'app SCM_DO_BUILD_DURING_DEPLOYMENT nel portale di Azure o nell'interfaccia della riga di comando di Azure.
Selezionare Configurazione sotto l'intestazione Impostazioni nella barra degli strumenti a sinistra per visualizzare le impostazioni dell'applicazione.
In Impostazioni applicazione selezionare Nuova impostazione applicazione.
Usando la finestra di dialogo, immettere una nuova impostazione con:
Nome → SCM_DO_BUILD_DURING_DEPLOYMENT Valore → true
Per salvare le impostazioni, selezionare Salva.
Usare il comando az webapp config appsettings set per definire l’impostazione SCM_DO_BUILD_DURING_DEPLOYMENT per un valore true.
# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'
az webapp config appsettings set \
--resource-group $RESOURCE_GROUP_NAME \
--name $APP_SERVICE_NAME \
--settings SCM_DO_BUILD_DURING_DEPLOYMENT=true
# Change these values to the ones used to create the App Service.
$resourceGroupName='msdocs-python-webapp-quickstart'
$appServiceName='msdocs-python-webapp-quickstart-123'
az webapp config appsettings set `
--resource-group $resourceGroupName `
--name $appServiceName `
--settings SCM_DO_BUILD_DURING_DEPLOYMENT=true
Creare un file ZIP dell'applicazione
Successivamente, creare un file ZIP dell'applicazione. È sufficiente includere componenti dell'applicazione stessa. Non è necessario includere file o directory che iniziano con un punto (.), ad esempio .venv, .gitignore, .github o .vscode.
# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'
az webapp deploy \
--name $APP_SERVICE_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--src-path <zip-file-path>
# Change these values to the ones used to create the App Service.
$resourceGroupName='msdocs-python-webapp-quickstart'
$appServiceName='msdocs-python-webapp-quickstart-123'
az webapp deploy `
--name $appServiceName `
--resource-group $resourceGroupName `
--src-path <zip-file-path>
Per usare cURL per caricare il file ZIP in Azure, è necessario il nome utente e la password di distribuzione per il Servizio app. Queste credenziali possono essere ottenute dal portale di Azure.
Nella pagina dell’app Web, selezionare Centro distribuzione dal menu a sinistra della pagina.
Selezionare la scheda Credenziali FTPS.
Nome utente e Password vengono visualizzati sotto l’intestazione Ambito applicazione. Per le distribuzioni di file ZIP, usare solo la parte del nome utente dopo il carattere \ che inizia con $, ad esempio $msdocs-python-webapp-quickstart-123. Queste credenziali saranno necessarie nel comando cURL.
Usare il comando curl seguente per caricare il file ZIP in Azure e distribuire l'applicazione. Il nome utente è il nome utente di distribuzione ottenuto nel passaggio 3. Quando viene eseguito questo comando, verrà chiesta la password di distribuzione.
Per PowerShell, è necessario racchiudere il nome utente tra virgolette singole in modo che PowerShell non tenti di interpretare il nome utente come variabile di PowerShell.
In base alla presenza di determinati file in una distribuzione, il Servizio app rileva automaticamente se un'app è un'app Django o Flask ed esegue i passaggi predefiniti per eseguire l'app. Per le app basate su altri framework Web come FastAPI, è necessario configurare uno script di avvio per l'esecuzione dell'app da parte del Servizio app; in caso contrario, il Servizio app esegue un'app di sola lettura predefinita che si trova nella cartella opt/defaultsite.
Il Servizio app rileva automaticamente la presenza di un'app Flask. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Il Servizio app rileva automaticamente la presenza di un'app Django. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Per FastAPI, è necessario configurare un comando di avvio personalizzato per l'esecuzione dell'app da parte del Servizio app. Il comando seguente avvia Gunicorn con processi di lavoro 2 Uvicorn: gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app.
Prima di tutto, configurare il comando di avvio usando il comando az webapp config set.
az webapp config set \
--startup-file "gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app" \
--name $APP_SERVICE_NAME \
--resource-group $RESOURCE_GROUP_NAME
az webapp restart \
--name $APP_SERVICE_NAME \
--resource-group $RESOURCE_GROUP_NAME
Il Servizio app rileva automaticamente la presenza di un'app Flask. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Il Servizio app rileva automaticamente la presenza di un'app Django. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Usare l'interfaccia della riga di comando di Azure o il portale di Azure per configurare il comando di avvio.
Il Servizio app rileva automaticamente la presenza di un'app Flask. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Il Servizio app rileva automaticamente la presenza di un'app Django. Per questo avvio rapido non è necessaria alcuna configurazione aggiuntiva.
Per FastAPI, è necessario configurare un comando di avvio personalizzato per l'esecuzione dell'app da parte del Servizio app. Il comando seguente avvia Gunicorn con processi di lavoro 2 Uvicorn: gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app.
Istruzioni
Schermata
Configurare prima di tutto il comando di avvio nel Servizio app di Azure. Andare alla pagina dell'istanza del Servizio app nel portale di Azure.
Selezionare Configurazione nell'intestazione Impostazioni nel menu a sinistra della pagina.
Assicurarsi che sia selezionata la scheda Impostazioni generali.
Nel campo Comando di avvio immettere gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app.
Seleziona Salva per salvare le modifiche.
Attendere la notifica che le impostazioni vengono aggiornate prima di procedere.
Successivamente, riavviare l'app Web.
Selezionare Panoramica nel menu a sinistra della pagina.
Nel menu in alto selezionare Riavvia.
Passare all'app
Passare all'applicazione distribuita nel Web browser usando l'URL http://<app-name>.azurewebsites.net. Se viene visualizzata una pagina dell'app predefinita, attendere un minuto e aggiornare il browser.
Il codice di esempio Python esegue un contenitore Linux nel Servizio app usando un'immagine predefinita.
Complimenti. La distribuzione dell'app Python nel Servizio app di Azure è stata completata.
Il servizio app di Azure acquisisce tutto l’output dei messaggi nella console per facilitare la diagnosi dei problemi con l'applicazione. Le app di esempio includono istruzioni print() per illustrare questa funzionalità.
@app.route('/')
def index():
print('Request for index page received')
return render_template('index.html')
@app.route('/favicon.ico')
def favicon():
return send_from_directory(os.path.join(app.root_path, 'static'),
'favicon.ico', mimetype='image/vnd.microsoft.icon')
@app.route('/hello', methods=['POST'])
def hello():
name = request.form.get('name')
if name:
print('Request for hello page received with name=%s' % name)
return render_template('hello.html', name = name)
else:
print('Request for hello page received with no name or blank name -- redirecting')
return redirect(url_for('index'))
def index(request):
print('Request for index page received')
return render(request, 'hello_azure/index.html')
@csrf_exempt
def hello(request):
if request.method == 'POST':
name = request.POST.get('name')
if name is None or name == '':
print("Request for hello page received with no name or blank name -- redirecting")
return redirect('index')
else:
print("Request for hello page received with name=%s" % name)
context = {'name': name }
return render(request, 'hello_azure/hello.html', context)
else:
@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
print('Request for index page received')
return templates.TemplateResponse('index.html', {"request": request})
@app.get('/favicon.ico')
async def favicon():
file_name = 'favicon.ico'
file_path = './static/' + file_name
return FileResponse(path=file_path, headers={'mimetype': 'image/vnd.microsoft.icon'})
@app.post('/hello', response_class=HTMLResponse)
async def hello(request: Request, name: str = Form(...)):
if name:
print('Request for hello page received with name=%s' % name)
return templates.TemplateResponse('hello.html', {"request": request, 'name':name})
else:
print('Request for hello page received with no name or blank name -- redirecting')
return RedirectResponse(request.url_for("index"), status_code=status.HTTP_302_FOUND)
È possibile esaminare il contenuto dei log di diagnostica del servizio app usando l'interfaccia della riga di comando di Azure, VS Code o il portale di Azure.
Prima di tutto, è necessario configurare il servizio app di Azure per l'output dei log nel file system del servizio app usando il comando az webapp log config.
Prima di tutto, è necessario abilitare lo streaming dei log nel Servizio app di Azure.
Nella sezione Servizio app dell'estensione Strumenti di Azure per VS Code, fare clic con il pulsante destro del mouse sull'istanza del Servizio app e scegliere Avvia streaming dei log dal menu.
I log della console vengono visualizzati nella finestra di output di VS Code. Aggiornare la home page nell'app o tentare altre richieste per la generazione di alcuni messaggi di log.
Verranno visualizzati tutti i messaggi di log generati dall'app e altri messaggi generati dal servizio nell'output.
Istruzioni
Schermata
Prima di tutto, è necessario abilitare lo streaming dei log nel Servizio app di Azure. Andare alla pagina dell'istanza del Servizio app nel portale di Azure.
Selezionare Log del servizio app sotto l'intestazione Monitoraggio nel menu a sinistra della pagina.
Modificare la proprietà Registrazione applicazione da Disattivata a File system.
Immettere un periodo di conservazione di 30 giorni per i log.
Seleziona Salva per salvare le modifiche.
Selezionare Flusso di log nella sezione Monitoraggio nel riquadro di spostamento a sinistra. Aggiornare la home page nell'app o tentare altre richieste per la generazione di alcuni messaggi di log.
Verranno visualizzati tutti i messaggi di log generati dall'app e i messaggi generati dal servizio nell'output.
Al termine dell'app di esempio, è possibile rimuovere da Azure tutte le risorse per l'app. La rimozione del gruppo di risorse consente di evitare addebiti aggiuntivi e di mantenere in ordine la sottoscrizione di Azure. La rimozione del gruppo di risorse rimuove anche tutte le risorse nel gruppo di risorse ed è il modo più rapido per rimuovere tutte le risorse di Azure per l'app.
Eliminare il gruppo di risorse mediante il comando az group delete.
az group delete \
--name msdocs-python-webapp-quickstart \
--no-wait
Con l'argomento --no-wait, il comando restituisce il risultato prima del completamento dell'operazione.
Istruzioni
Schermata
Nell’estensione Strumenti di Azure per VS Code:
Trovare la sezione RISORSE.
Selezionare l'icona Raggruppa per e selezionare Raggruppa per gruppo di risorse.
Nell'elenco delle risorse, trovare il gruppo di risorse da eliminare, fare clic con il pulsante destro del mouse e selezionare Elimina gruppo di risorse.... Verrà chiesto di confermare l'eliminazione immettendo il nome del gruppo di risorse nella finestra di dialogo.
Seguire questa procedura durante l'accesso al portale di Azure per eliminare un gruppo di risorse.
Istruzioni
Schermata
Passare al gruppo di risorse nel portale di Azure.
Immettere il nome del gruppo di risorse nella barra di ricerca nella parte superiore della pagina.
Sotto l’intestazione Gruppi di risorse, selezionare il nome del gruppo di risorse a cui passare.
Selezionare il pulsante Elimina gruppo di risorse nella parte superiore della pagina.
Nella finestra di dialogo di conferma, immettere il nome del gruppo di risorse per confermare l'eliminazione. Selezionare Elimina per eliminare il gruppo di risorse.
