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

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? Segnalarli.

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? Segnalarli.

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? Segnalarli.

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.

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>"
}

Per creare risorse di Azure in VS Code, è necessario installare il pacchetto di estensione Strumenti di Azure e accedere 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 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.

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.

• Azure portal
• Interfaccia della riga di comando di Azure

Istruzioni	Schermata
Passare al Servizio app per l'applicazione. 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.

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.

• Azure portal
• 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
Per salvare le impostazioni, selezionare Salva.

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> \
    https://<app-name>.scm.azurewebsites.net/api/zipdeploy

curl -X POST `
    -H 'Content-Type: application/zip' `
    -u '<deployment-user>' `
    -T <zip-file-name> `
    https://<app-name>.scm.azurewebsites.net/api/zipdeploy

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

Riavviare 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.

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.

@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, è 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.

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 eseguire lo streaming dei 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 essere 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 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.

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.