Esercitazione: Usare il framework Web Django in Visual Studio

Questo articolo è il primo passaggio di una serie di esercitazioni in cinque parti che illustra come usare Django in Visual Studio. Django è un framework Python di alto livello progettato per lo sviluppo Web rapido, sicuro e scalabile. Visual Studio fornisce modelli di progetto che è possibile usare per semplificare la creazione di applicazioni Web basate su Django. Questa serie di esercitazioni esplora il framework Django nel contesto dei modelli di progetto di Visual Studio.

Nel passaggio 1 dell'esercitazione si apprenderà come:

• Creare un progetto di applicazione web Django utilizzando il modello Progetto Web Django vuoto
• Esaminare il codice boilerplate ed eseguire l'app
• Creare un repository Git per l'app Web Django
• Usare i controlli del codice sorgente Git
• Creare un ambiente virtuale per l'app Web Django

Prerequisiti

• Visual Studio 2022 o versione successiva in Windows con le opzioni seguenti selezionate nel programma di installazione di Visual Studio:

  • Nella scheda Carichi di lavoro selezionare l'opzione sviluppo Python . Per altre informazioni, vedere Installare il supporto python in Visual Studio.

  • Nella scheda Singoli componenti in Strumenti di codice selezionare l'opzione Git per Windows .

I modelli di progetto Django in Visual Studio sono inclusi in tutte le versioni precedenti di Python Tools per Visual Studio. I dettagli del modello potrebbero differire dalle descrizioni di questa serie di esercitazioni, in particolare per le versioni precedenti del framework Web Django.

Visual Studio per Mac non è supportato. Per altre informazioni, vedere Cosa accade a Visual Studio per Mac? Visual Studio Code in Windows, Mac e Linux funziona bene con Python tramite le estensioni disponibili.

Progetti di Visual Studio e progetti Django

Nella terminologia di Django un progetto Django include diversi file di configurazione a livello di sito insieme a una o più "app". Per creare un'applicazione Web completa, è possibile distribuire queste app in un host Web. Un progetto Django può contenere più app e la stessa app può trovarsi in più progetti Django.

Un progetto di Visual Studio può contenere il progetto Django insieme a più app. In questa serie di esercitazioni il termine "progetto" si riferisce al progetto di Visual Studio. Quando il contenuto fa riferimento alla parte "Progetto Django" dell'applicazione Web, si riferisce in particolare a un "progetto Django".

Creare un progetto e una soluzione di Visual Studio

Nel passaggio 1 di questa serie di esercitazioni si crea una singola soluzione di Visual Studio per contenere più progetti Django. Ogni progetto contiene una singola app Django. I progetti vengono creati usando modelli di progetto Django diversi inclusi in Visual Studio. Mantenendo i progetti nella stessa soluzione, è possibile passare facilmente da un file all'altro per il confronto.

Quando si usa Django dalla riga di comando, in genere si avvia un progetto eseguendo il django-admin startproject <project_name> comando . All'interno di Visual Studio, il modello Progetto Web Django vuoto fornisce una struttura identica sia per il progetto che per la soluzione di Visual Studio.

Seguire questa procedura per creare la soluzione e il progetto:

1. In Visual Studio selezionare File>Nuovo>progetto e cercare "Django". Selezionare quindi il modello Progetto Web Django vuoto e selezionare Avanti.

   

2. Configurare il nuovo progetto e la soluzione:

   1. Impostare Il nome del progetto di Visual Studio su BasicProject. Questo nome viene usato anche per il progetto Django.

   2. Specificare il percorso per Visual Studio per salvare la soluzione e il progetto.

   3. Deselezionare l'opzione Inserisci soluzione e progetto nella stessa directory .

   4. Impostare il nome della soluzione a LearningDjango. La soluzione funge da contenitore per più progetti in questa serie di esercitazioni.

3. Fare clic su Crea.

4. Dopo qualche istante, Visual Studio visualizza il file di specifica del pacchetto Python "requirements.txt" rilevato nel progetto "BasicProject".:

   

   La finestra di dialogo indica che il modello selezionato include un filerequirements.txt che è possibile usare per creare un ambiente virtuale per il progetto.

5. Selezionare la X a destra per chiudere il prompt. Più avanti in questa esercitazione si crea l'ambiente virtuale e si verifica che il controllo del codice sorgente escluda l'ambiente. L'ambiente può sempre essere creato successivamente dal file requirements.txt.

Esaminare i controlli Git

Nella procedura successiva si acquisisce familiarità con il supporto di Visual Studio per il controllo del codice sorgente Git.

Importante

In Visual Studio 2019 e versioni successive l'esperienza di controllo della versione Git è attivata per impostazione predefinita. Per altre informazioni sul confronto con Team Explorer, vedere la pagina Confronto side-by-side di Git e Team Explorer .

Se si preferisce continuare a usare Team Explorer nelle versioni precedenti di Visual Studio, passare a Strumenti>Opzioni>Ambiente>Funzionalità di anteprima e attivare la casella di controllo Nuova esperienza utente Git .

1. Per eseguire il commit del progetto nel controllo del codice sorgente locale, selezionare Aggiungi al controllo del codice sorgente in basso a destra nella finestra principale di Visual Studio e quindi selezionare Git:

   

   Viene visualizzata la finestra Crea repository Git in cui è possibile creare ed eseguire il push di un nuovo repository.

2. Dopo aver creato un repository, la barra dei controlli Git viene visualizzata in basso a destra nella finestra principale di Visual Studio:

   

   Da sinistra a destra, la barra dei controlli Git mostra il numero di commit in uscita/in ingresso (frecce #/#), il numero di modifiche di cui non è stato eseguito il commit (matita #), il nome del ramo corrente e il nome del repository corrente. I controlli Git sono disponibili anche nel menu Git sulla barra degli strumenti principale.

3. Sulla barra dei controlli Git selezionare le modifiche (matita #) per aprire la finestra Modifiche Git . È anche possibile selezionare Visualizza>modifiche Git (CTRL+O, CTRL+G):

   

   Questa finestra mostra i dettagli relativi a eventuali modifiche non sottoposte a commit, incluse le modifiche accantonate. Poiché il progetto appena creato è stato automaticamente salvato nel controllo del codice sorgente, non vengono visualizzate modifiche in sospeso.

4. Nella barra dei controlli Git selezionare i commit (frecce #/#) e quindi selezionare Visualizza tutti i commit:

   

   Verrà visualizzata la finestra del repository Git . È anche possibile selezionare Visualizza>repository Git (CTRL+O, CTRL+R):

   

   Questa finestra mostra i dettagli del repository corrente nel riquadro sinistro e il ramo corrente con commit in uscita e in entrata nel riquadro destro.

   Per visualizzare la visualizzazione delle differenze per il file, selezionare un commit nel riquadro centrale. La versione precedente viene visualizzata sul lato sinistro e la versione rivista mostra sul lato destro. I dettagli contengono anche l'autore della modifica, il responsabile del commit delle modifiche e il messaggio di commit.

Durante l'esecuzione di questa serie di esercitazioni, è possibile usare periodicamente i controlli Git in Visual Studio per eseguire il commit e il push delle modifiche. I passaggi del tutorial ti ricordano al momento opportuno.

Usare il controllo del codice sorgente dall'inizio

L'uso del controllo del codice sorgente dall'inizio di un progetto offre diversi vantaggi. Quando si usa il controllo del codice sorgente dall'inizio di un progetto, soprattutto se si usa anche un repository remoto, si ottiene un normale backup fuori sede del progetto. A differenza della gestione di un progetto solo in un file system locale, il controllo del codice sorgente fornisce anche una cronologia delle modifiche completa e la possibilità di ripristinare un singolo file o l'intero progetto a uno stato precedente. La cronologia delle modifiche consente di determinare la causa delle regressioni (errori di test).

Il controllo del codice sorgente è essenziale se più persone lavorano su un progetto, perché gestisce le sovrascrizioni e fornisce la risoluzione dei conflitti. Il controllo del codice sorgente è fondamentalmente una forma di automazione, consente di automatizzare compilazioni, test e gestione delle versioni. Si tratta del primo passaggio nell'uso di Azure DevOps per un progetto e, poiché le barriere all'ingresso sono così basse, non c'è davvero motivo di non usare il controllo del codice sorgente fin dall'inizio.

Per altre informazioni sul controllo del codice sorgente come automazione, vedere The Source of Truth: The Role of Repository in DevOps, un articolo di MSDN Magazine scritto per le app per dispositivi mobili che si applicano anche alle app Web.

Impedire a Visual Studio di eseguire il commit automatico dei progetti

Seguire questa procedura per impedire a Visual Studio di eseguire il commit automatico di un nuovo progetto:

1. Aprire il riquadro Opzioni strumenti> ed espandere la sezione Tutte le impostazioni>controllo> del codice sorgenteImpostazioni Git.

2. Deselezionare l'opzione Commit changes after merge by default.

Creare un ambiente virtuale ed escludere il controllo del codice sorgente

Dopo aver configurato il controllo del codice sorgente per il progetto, è possibile creare l'ambiente virtuale con i pacchetti Django necessari per il progetto. È quindi possibile usare la finestra Modifiche Git per escludere la cartella dell'ambiente dal controllo del codice sorgente.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Ambienti Python e scegliere Aggiungi ambiente.

   

2. Nella finestra di dialogo Aggiungi ambiente selezionare Crea per accettare i valori predefiniti. È possibile modificare il nome dell'ambiente virtuale, se necessario, che modifica il nome della relativa sottocartella, ma env è una convenzione standard.

   

3. Se Visual Studio richiede privilegi di amministratore, fornire il consenso. Attendere alcuni minuti mentre Visual Studio scarica e installa i pacchetti. Per Django e le relative dipendenze, il processo può richiedere l'espansione di circa 1.000 file in oltre 100 sottocartelle. È possibile visualizzare lo stato di avanzamento nella finestra Output di Visual Studio.

4. Nella barra dei controlli Git selezionare le modifiche di cui non è stato eseguito il commit (che ora mostra 99+) per aprire la finestra Modifiche Git :

   

   La creazione dell'ambiente virtuale comporta migliaia di modifiche, ma non è necessario includerle nel controllo del codice sorgente. L'utente o chiunque altro che cloni il progetto può sempre ricreare l'ambiente usando il file requirements.txt .

5. Per escludere l'ambiente virtuale dal controllo del codice sorgente, nella finestra Modifiche Git fare clic con il pulsante destro del mouse sulla cartella env e scegliere Ignora questi elementi locali:

   

   Dopo aver escluso l'ambiente virtuale, le uniche modifiche rimanenti vengono apportate al file di progetto (.py) e al file con estensione gitignore , che contiene una voce aggiunta per la cartella dell'ambiente virtuale.

   Per visualizzare la visualizzazione delle differenze per il file con estensione gitignore , nella finestra Modifiche Git fare doppio clic sul file.

6. Nella finestra Modifiche Git immettere un messaggio di commit, ad esempio "Modifiche iniziali del progetto":

   

7. Nel menu a discesa Commit selezionare Commit Staged e Push.

È possibile aprire la finestra Repository Git e confermare che i commit di staging vengono visualizzati nella cronologia locale per il ramo corrente.

Comprendere lo scopo degli ambienti virtuali

Un ambiente virtuale è un ottimo modo per isolare le dipendenze esatte dell'applicazione. Questo metodo di isolamento evita i conflitti all'interno di un ambiente Python globale e facilita sia i test che la collaborazione. Nel corso del tempo, man mano che si sviluppa un'app, si apportano invariabilmente molti pacchetti Python utili. Mantenendo i pacchetti in un ambiente virtuale specifico del progetto, è possibile aggiornare facilmente il file direquirements.txt del progetto che descrive tale ambiente, incluso nel controllo del codice sorgente. Quando si copia il progetto in altri computer, inclusi server di compilazione, server di distribuzione e altri computer di sviluppo, è facile ricreare l'ambiente. È possibile ricreare l'ambiente usando solo il file requirements.txt , motivo per cui l'ambiente non deve essere incluso nel controllo del codice sorgente. Per altre informazioni, vedere Usare ambienti virtuali.

Rimuovere l'ambiente virtuale sotto il controllo del codice sorgente

È possibile rimuovere un ambiente virtuale dopo che è sotto il controllo del codice sorgente. Segui questi passaggi:

1. Modifica il file .gitignore per escludere la cartella:

   1. Aprire il file selezionando File>Apri>file.

      È anche possibile aprire il file da Team Explorer. Nella pagina Impostazioni selezionare Impostazioni del repository. Passare alla sezione Ignora file e attributi e selezionare il collegamento Modifica accanto a .gitignore.

   2. Individuare la sezione alla fine con il commento # Python Tools for Visual Studio (PTVS).

   3. Dopo questa sezione, aggiungere una nuova riga per la cartella dell'ambiente virtuale, ad esempio /BasicProject/env.

2. Aprire una finestra di comando e passare alla cartella (ad esempio BasicProject) con la cartella dell'ambiente virtuale, ad esempio env.

3. Eseguire il git rm -r env comando per rimuovere l'ambiente virtuale attualmente sotto il controllo del codice sorgente.

4. Esegui il commit delle modifiche con il comando git commit -m 'Remove venv', oppure effettuane il commit dalla pagina Modifiche di Team Explorer.

Esaminare il codice boilerplate

In questa sezione viene esaminato il codice boilerplate nel file di progetto (.py) creato da Visual Studio in base alla selezione del modello.

Annotazioni

Il codice boilerplate è lo stesso se si crea il progetto in Visual Studio dal modello Django o si genera il progetto usando il comando dell'interfaccia della riga di comando django-admin startproject <project_name>.

1. Aprire Esplora soluzioni per visualizzare i file di soluzione e di progetto. Il progetto iniziale contiene solo due file, manage.py e requirements.txt:

   

   Il file requirements.txt specifica le dipendenze del pacchetto Django. La presenza di questo file è ciò che invita a creare un ambiente virtuale durante la creazione del progetto.

   Il file manage.py è l'utilità amministrativa della riga di comando Django impostata automaticamente da Visual Studio come file di avvio del progetto. Puoi eseguire l'utilità nella riga di comando usando il comando python manage.py <command> [options].

   Per le attività django comuni, Visual Studio offre comandi di menu pratici. Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e selezionare Python per visualizzare l'elenco dei comandi. In questa serie di esercitazioni vengono usati diversi di questi comandi.

2. Oltre ai due file, il progetto ha anche una sottocartella con lo stesso nome del progetto. Questa cartella contiene i file di progetto Django di base:

   

   • __init__.py: file vuoto che indica a Python che questa cartella è un pacchetto Python.
   • settings.py: le impostazioni per il progetto Django, che vengono modificate durante lo sviluppo di un'app Web.
   • urls.py: sommario per il progetto Django, modificato durante lo sviluppo dell'app Web.
   • wsgi.py: punto di ingresso per i server Web compatibili con WSGI per gestire il progetto. In genere si lascia questo file as-is perché fornisce gli hook per i server Web di produzione.

Generare i requisiti dopo l'installazione del pacchetto

Visual Studio può generare un filerequirements.txt da un ambiente virtuale dopo l'installazione di altri pacchetti.

• In Esplora soluzioni espandere il nodo Ambienti Python , fare clic con il pulsante destro del mouse sull'ambiente virtuale e selezionare Genera requirements.txt.

È consigliabile usare periodicamente questo comando quando si modifica l'ambiente. Fai il commit delle modifiche apportate al file requirements.txt nel controllo del sorgente insieme a qualsiasi altra modifica del codice che dipendono da quell'ambiente. Se si configura l'integrazione continua in un server di compilazione, è necessario generare il file ed eseguire il commit delle modifiche ogni volta che si modifica l'ambiente.

Eseguire il progetto

A questo momento è possibile eseguire il progetto in Visual Studio seguendo questa procedura:

1. In Visual Studio selezionare Debug>Avvia debug (F5) oppure selezionare server Web sulla barra degli strumenti principale (il browser visualizzato potrebbe variare):

   

2. Entrambi i comandi eseguano il server usando il comando manage.py runserver <port>, che avvia il server Web predefinito in Django.

   Il codice avvia l'applicazione usando la porta specificata all'interno del server di sviluppo Django.

   Se Visual Studio pubblica il messaggio Impossibile avviare il debugger e indica che non viene trovato alcun file di avvio, fare clic con il pulsante destro del mouse sul file manage.py in Esplora soluzioni e scegliere Imposta come file di avvio.

3. All'avvio del server, viene visualizzata una finestra della console per visualizzare il log del server. Visual Studio apre automaticamente un browser a http://localhost:<port>. Poiché il progetto Django non ha app, Django visualizza solo una pagina predefinita per verificare che il codice corrente funzioni come previsto.

   

4. Al termine, chiudere la finestra della console che arresta il server di sviluppo Django. È anche possibile selezionare Debug>Arresta debug.

Usare il server Web e il framework Django

Django dispone di un server Web predefinito che è possibile usare a scopo di sviluppo. Quando si esegue l'app Web Django in locale, si usa il server di sviluppo Web Django predefinito. Un esempio di questo scenario è quando si esegue il debug dell'app Web Django in Visual Studio.

Quando si distribuisce l'app Web Django in un host Web, si usa il server Web nell'host anziché il server Web Django predefinito. Il modulo wsgi.py nel progetto Django si occupa dell'associazione ai server di produzione.

Confrontare i comandi di debug con i comandi Python del progetto,

Esiste una differenza tra l'uso dei comandi di menu Debug e dei comandi del server elencati nel sottomenu Python del progetto.

Oltre ai comandi di menu Debug e ai pulsanti della barra degli strumenti, è anche possibile avviare il server usando i> comandi PythonStart server o PythonStart debug server nel menu di scelta rapida del progetto.

Entrambi i comandi aprono una finestra della console in cui viene visualizzato l'URL locale (localhost:port) per il server in esecuzione. Tuttavia, è necessario aprire manualmente un browser con tale URL e l'esecuzione del server di debug non avvia automaticamente il debugger di Visual Studio. È possibile collegare un debugger al processo in esecuzione in un secondo momento, se si vuole usare il comando Debug>Connetti a processo .

Passo successivo

Passaggio 2: Creare un'app Django con visualizzazioni e modelli di pagina