Avvio rapido: Distribuire un'app Web Python (Django, Flask o FastAPI) nel servizio app di Azure

mkdir flask-quickstart
cd flask-quickstart
azd init --template https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart
azd up

mkdir django-quickstart
cd django-quickstart
azd init --template https://github.com/Azure-Samples/msdocs-python-django-webapp-quickstart
azd up

mkdir fastapi-quickstart
cd fastapi-quickstart
azd init --template https://github.com/Azure-Samples/msdocs-python-fastapi-webapp-quickstart
azd up

git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart

git clone https://github.com/Azure-Samples/msdocs-python-django-webapp-quickstart

git clone https://github.com/Azure-Samples/msdocs-python-fastapi-webapp-quickstart.git

1. Passare alla cartella dell'applicazione:

   cd msdocs-python-flask-webapp-quickstart
   

2. Creare un ambiente virtuale per l’app:

   • Windows
   • macOS/Linux

   py -m venv .venv
   .venv\scripts\activate
   

3. Installare le dipendenze:

   pip install -r requirements.txt
   

4. Eseguire l'app:

   flask run
   

5. Passare all'applicazione di esempio in http://localhost:5000 un Web browser.

   

Problemi? Fateci sapere.

1. Passare alla cartella dell'applicazione:

   cd msdocs-python-django-webapp-quickstart
   

2. Creare un ambiente virtuale per l’app:

   • Windows
   • macOS/Linux

   py -m venv .venv
   .venv\scripts\activate
   

3. Installare le dipendenze:

   pip install -r requirements.txt
   

4. Eseguire l'app:

   python manage.py runserver
   

5. Passare all'applicazione di esempio in http://localhost:8000 un Web browser.

   

Problemi? Fateci sapere.

1. Passare alla cartella dell'applicazione:

   cd msdocs-python-fastapi-webapp-quickstart
   

2. Creare un ambiente virtuale per l’app:

   • Windows
   • macOS/Linux

   py -m venv .venv
   .venv\scripts\activate
   

3. Installare le dipendenze:

   pip install -r requirements.txt
   

4. Eseguire l'app:

   uvicorn main:app --reload
   

5. Passare all'applicazione di esempio in http://localhost:8000 un Web browser.

   

Problemi? Fateci sapere.

I comandi dell'interfaccia della riga di comando di Azure possono essere eseguiti in un computer con l'interfaccia della riga di comando di Azure installata.

Crea le risorse Azure e poi distribuisci la tua applicazione usando comandi separati per interfaccia della riga di comando di Azure.

Se necessario, accedere ad Azure usando az login.

az login

Sostituisci <app-name> con un nome unico a livello globale. Crea un gruppo di risorse e un piano di App Service, poi crea l'app web usando az webapp create.

az group create --name myResourceGroup --location eastus
az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku P0v3 --is-linux
az webapp create --name <app-name> --resource-group myResourceGroup --plan myAppServicePlan --runtime "PYTHON:3.14"
az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings SCM_DO_BUILD_DURING_DEPLOYMENT=true

• Usa il parametro --runtime per specificare la versione di Python su cui viene eseguita la tua app. Questo esempio utilizza Python 3.14. Per elencare i runtime Python supportati, usa az webapp list-runtimes --os-type linux --runtime python --output table.
• Usa il --sku parametro per definire la dimensione (CPU e memoria) e il costo del piano App Service. Questo esempio utilizza il piano di servizio P0v3 (Premium v3), che comporta un costo nel tuo abbonamento Azure. Per un elenco completo dei piani di servizio app, vedere Prezzi del servizio app.
• Sostituisci eastus con la tua regione preferita. Per elencare le regioni disponibili, esegui az account list-locations con --output table.
• L'impostazione SCM_DO_BUILD_DURING_DEPLOYMENT consente la build di Oryx, inclusa l'installazione delle dipendenze in requirements.txt, quando si distribuisce l'archivio sorgente.

Crea un file ZIP con i file dell'applicazione, incluso requirements.txt, alla radice dell'archivio. Escludere file locali come .venv, .git e .env. Per istruzioni specifiche per la piattaforma, vedi Crea un file ZIP della tua applicazione nella scheda Deploy usando un file ZIP. Poi distribuisci l'archivio usando az webapp deploy:

az webapp deploy --name <app-name> --resource-group myResourceGroup --src-path <zip-file-path> --type zip

La distribuzione può richiedere alcuni minuti. Naviga fino a https://<app-name>.azurewebsites.net per visualizzare la tua app. Per visualizzare i log in streaming, abilitali eseguendo az webapp log config --name <app-name> --resource-group myResourceGroup --docker-container-logging filesystem, quindi esegui az webapp log tail --name <app-name> --resource-group myResourceGroup.

Per creare risorse di Azure in VS Code, è necessario avere installato il pacchetto di estensione Strumenti di Azure e aver eseguito l'accesso ad Azure da VS Code.

Nella cartella dell'applicazione, aprire VS Code:

code .

Istruzioni	Schermata
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 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, dove XYZ è costituito da tre caratteri univoci. Quando viene distribuito, questo nome viene usato come nome dell'app.
Selezionare lo stack di runtime per l'applicazione. In questo esempio selezionare Python 3.14.
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 "Creazione di una nuova app Web".
Selezionare la cartella di avvio rapido in cui si sta lavorando come cartella da distribuire.
Risposta Sì per aggiornare la configurazione della compilazione e migliorare le prestazioni di 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.

Accedere al portale di Azure e seguire questa procedura per creare le risorse del servizio app di Azure.

Istruzioni	Schermata
Nel portale di Azure: Immettere i servizi app nella barra di ricerca nella parte superiore del portale di Azure. Selezionare l'elemento con etichetta Servizi app sotto l'intestazione Servizi nel menu visualizzato sotto la barra di ricerca.
Nella pagina Servizi app selezionare + Crea, quindi selezionare + App Web dal menu a discesa.
Nella pagina Crea app Web compilare 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.14. Area → Qualsiasi area di Azure nelle vicinanze. Piano di servizio app → In Piano tariffario selezionare Esplora piani tariffari per selezionare un piano di servizio app diverso.
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, selezionare Seleziona per applicare le modifiche.
Nella pagina principale Crea app Web selezionare Rivedi e crea nella parte inferiore della schermata. Viene visualizzata la pagina Rivedi. Selezionare Crea per creare il servizio app.

I comandi interfaccia della riga di comando di Azure nel passaggio precedente hanno creato le risorse e distribuito la tua applicazione. Puoi passare al passo 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.

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.

• Portale di Azure
• Interfaccia della riga di comando di Azure

Istruzioni	Schermata
Nella pagina per l'app Web nel portale 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
Selezionare Salva per salvare le impostazioni.

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.

zip -r <file-name>.zip . -x '.??*'

Caricare il file ZIP in Azure

Dopo aver creato un file ZIP, il file può essere caricato in Azure usando l'interfaccia della riga di comando di Azure o un client HTTP come cURL.

# 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>

curl -X POST \
    -H 'Content-Type: application/zip' \
    -u '<deployment-user>' \
    -T <zip-file-name> \
    <URL>

curl -X POST `
    -H 'Content-Type: application/zip' `
    -u '<deployment-user>' `
    -T <zip-file-name> `
    <URL>

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.

Se usi Python 3.14 o versioni successive, App Service rileva e esegue automaticamente la tua app FastAPI. Non è necessaria alcuna configurazione aggiuntiva per questo avvio rapido.

Se usi Python 3.13 o versioni precedenti, devi configurare un comando di avvio personalizzato per App Service per eseguire la tua app. Il seguente comando avvia Gunicorn con due processi di lavoro 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

Riavviare quindi l'app Web usando il comando az webapp restart .

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.

Se usi Python 3.13 o precedente, usa interfaccia della riga di comando di Azure o il portale 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.

Se usi Python 3.14 o versioni successive, App Service rileva e esegue automaticamente la tua app FastAPI. Non serve alcuna configurazione extra per questo avvio rapido.

Se usi Python 3.13 o versioni precedenti, devi configurare un comando di avvio personalizzato per App Service per eseguire la tua app. Il seguente comando avvia Gunicorn con due processi di lavoro Uvicorn: gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app.

Istruzioni	Schermata
Se usi Python 3.13 o precedente, configura il comando di avvio in Servizio app di Azure. Vai all'istanza App Service nel portale Azure. Selezionare Configurazione sotto l'intestazione Impostazioni nel menu a sinistra della pagina. Assicurarsi che la scheda Impostazioni generali sia selezionata. Nel campo Comando di avvio immettere gunicorn -w 2 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app. Selezionare Salva per salvare le modifiche. Attendere la notifica che le impostazioni vengono aggiornate prima di procedere. Se usi Python 3.14 o successiva, non è necessario alcun comando di avvio.
Successivamente, riavviare l'app Web. Selezionare Panoramica nel menu a sinistra della pagina. Nel menu in alto selezionare Riavvia.

@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)

Prima di tutto, devi configurare il Servizio App di Azure per l'output dei log nel file system del Servizio App usando il comando az webapp log config.

az webapp log config \
    --web-server-logging filesystem \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME

az webapp log config `
    --web-server-logging 'filesystem' `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME

Per trasmettere i log, usare il comando az webapp log tail .

az webapp log tail \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME

az webapp log tail `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME

Aggiornare la home page nell'app o tentare altre richieste per la generazione di alcuni messaggi di log. L'output dovrebbe avere un aspetto simile al seguente.

Starting Live Log Stream ---

2021-12-23T02:15:52.740703322Z Request for index page received
2021-12-23T02:15:52.740740222Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET / HTTP/1.1" 200 1360 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:52.841043070Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 200 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:52.884541951Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 200 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:53.043211176Z 169.254.130.1 - - [23/Dec/2021:02:15:53 +0000] "GET /favicon.ico HTTP/1.1" 404 232 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

2021-12-23T02:16:01.304306845Z Request for hello page received with name=David
2021-12-23T02:16:01.304335945Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "POST /hello HTTP/1.1" 200 695 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:16:01.398399251Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 304 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:16:01.430740060Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 304 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

Eliminare il gruppo di risorse usando 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.

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. Nell'intestazione Gruppi di risorse selezionare il nome del gruppo di risorse per passare a esso.
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.