Condividi tramite

Compilare ed eseguire un'app Web Python in contenitori in locale

  • Articolo

Questo articolo illustra come compilare ed eseguire un'app Web Django in contenitori o Flask Python nel computer locale. Per archiviare i dati per questa app, è possibile usare un'istanza locale di MongoDB o Azure Cosmos DB per MongoDB. Questo articolo è la parte 2 di una serie di esercitazioni in 5 parti. È consigliabile completare la parte 1 prima di iniziare questo articolo.

Il diagramma dei servizi seguente illustra i componenti locali illustrati in questo articolo In questo articolo viene illustrato anche come usare Azure Cosmos DB per MongdoDB con un'immagine Docker locale, anziché un'istanza locale di MongoDB.

Schermata dell'esercitazione - App Python containerizzata in Azure con la parte locale evidenziata.

Clonare o scaricare l'app Python di esempio

In questa sezione si clona o si scarica l'app Python di esempio usata per compilare un'immagine Docker. È possibile scegliere tra un'app Web Django o Flask Python. Se si ha un'app Web Python personalizzata, è possibile scegliere di usarla. Se si usa la propria app Web Python, assicurarsi che l'app abbia un Dockerfile nella cartella radice e possa connettersi a un database MongoDB.

  1. Clonare il repository Django o Flask in una cartella locale usando uno dei comandi seguenti:

    # Django
git clone https://github.com/Azure-Samples/msdocs-python-django-container-web-app.git

# Flask
git clone https://github.com/Azure-Samples/msdocs-python-flask-container-web-app.git

  2. Vai alla cartella radice del tuo repository clonato.

    # Django
cd msdocs-python-django-container-web-app

# Flask
cd msdocs-python-flask-container-web-app

Creare un'immagine Docker

In questa sezione viene creata un'immagine Docker per l'app Web Python usando Visual Studio Code o l'interfaccia della riga di comando di Azure. L'immagine Docker contiene l'app Web Python, le relative dipendenze e il runtime Python. L'immagine Docker viene compilata da un Dockerfile che definisce il contenuto e il comportamento dell'immagine. Il Dockerfile si trova nella cartella radice dell'app di esempio clonata o scaricata (o fornita manualmente).

Visual Studio Code e l'estensione Docker sono necessari per compilare l'immagine Docker in locale usando Visual Studio Code. Installare Visual Studio Code e l'estensione Docker prima di continuare. Dopo aver installato Visual Studio Code e l'estensione Docker, passare alla cartella di esempio clonata o scaricata e aprire VS Code con il comando code ..

Annotazioni

I passaggi descritti in questa sezione richiedono l'esecuzione del daemon Docker. In alcune installazioni, ad esempio in Windows, è necessario aprire Docker Desktop per avviare il daemon prima di procedere.

  1. In VS Code aprire l'estensione Docker e quindi selezionare l'estensione Docker sulla barra delle attività.

    Screenshot che mostra come aprire l'estensione Docker in Visual Studio Code.

    Se l'estensione Docker segnala un errore "Non è stato possibile connettersi", assicurarsi che Docker sia installato ed eseguito.

  2. Per compilare l'immagine Docker, fare clic con il pulsante destro del mouse sul Dockerfile e quindi scegliere Compila immagine.

    Per altre informazioni sulla sintassi dockerfile, vedere le informazioni di riferimento sul Dockerfile.

  3. Per verificare che l'immagine sia stata compilata, espandere la sezione IMAGES dell'estensione Docker e cercare l'immagine compilata di recente. Il nome di questa immagine del contenitore è "msdocspythoncontainerwebapp" (questo valore viene impostato nel file .vscode/tasks.json ).

    Screenshot che mostra come confermare l'immagine predefinita in Visual Studio Code.

A questo punto, è disponibile un'immagine Docker locale denominata "msdocspythoncontainerwebapp" con il tag "latest". I tag consentono di definire i dettagli della versione, l'uso previsto, la stabilità e altre informazioni pertinenti. Per altre informazioni, vedere Raccomandazioni per l'assegnazione di tag e il controllo delle versioni delle immagini del contenitore.

Annotazioni

Le immagini compilate da VS Code o usando direttamente l'interfaccia della riga di comando di Docker possono essere visualizzate anche con l'applicazione Docker Desktop .

Configurare MongoDB

Per archiviare i dati, l'app Web Python richiede un database MongoDB denominato restaurants_reviews e una raccolta denominata restaurants_reviews . È possibile usare un'installazione locale di MongoDB o Azure Cosmos DB per MongoDB per creare e accedere al database e alla raccolta.

Importante

Non usare un database MongoDB usato nell'ambiente di produzione. In questa esercitazione si archivia la stringa di connessione MongoDB in una variabile di ambiente ( osservabile da chiunque sia in grado di controllare il contenitore, ad esempio usando docker inspect).

  1. Installare MongoDB (se non è già installato).

    È possibile verificare l'installazione di MongoDB usando mongoDB Shell (mongosh). Se i comandi seguenti non funzionano, potrebbe essere necessario installare in modo esplicito mongosh o connettere mongosh al server MongoDB.

    • Usare il comando seguente per aprire la shell MongoDB e ottenere la versione della shell MongoDB e del server MongoDB:

      mongosh

      Suggerimento

      Per restituire solo la versione del server MongoDB installato nel sistema, chiudere e riaprire la shell MongoDB e usare il comando seguente: mongosh --quiet --exec 'db.version()'

      In alcune configurazioni è anche possibile richiamare direttamente il daemon Mongo nella shell bash.

      mongod --version

  2. Modificare il file mongod.cfg nella \MongoDB\Server\8.0\bin cartella e aggiungere l'indirizzo IP locale del computer alla bindIP chiave.

    La bindip chiave nel file di configurazione MongoD definisce i nomi host e gli indirizzi IP su cui MongoDB è in ascolto per le connessioni client. Aggiungere l'indirizzo IP corrente del computer di sviluppo locale. L'app Web Python di esempio in esecuzione in locale in un contenitore Docker comunica al computer host con questo indirizzo.

    Ad esempio, una parte del file di configurazione dovrebbe essere simile alla seguente:

    net:
  port: 27017
  bindIp: 127.0.0.1,<local-ip-address>

  3. Salvare le modifiche apportate a questo file di configurazione.

    Importante

    Sono necessari privilegi amministrativi per salvare le modifiche apportate a questo file di configurazione.

  4. Riavviare MongoDB per selezionare le modifiche apportate al file di configurazione.

  5. Aprire una shell MongoDB ed eseguire il comando seguente per impostare il nome del database su "restaurants_reviews" e il nome della raccolta su "restaurants_reviews". È anche possibile creare un database e una raccolta con l'estensione MongoDB di VS Code o qualsiasi altro strumento compatibile con MongoDB.

    > help
> use restaurants_reviews
> db.restaurants_reviews.insertOne({})
> show dbs
> exit

Dopo aver completato il passaggio precedente, la stringa di connessione MongoDB locale è "mongodb://127.0.0.1:27017/", il nome del database è "restaurants_reviews" e il nome della raccolta è "restaurants_reviews".

Eseguire l'immagine localmente in un contenitore

È ora possibile eseguire il contenitore Docker in locale. L'app di esempio si aspetta che le informazioni di connessione di MongoDB vengano passate attraverso variabili di ambiente. Esistono diversi modi per passare le variabili di ambiente al contenitore in locale. Ognuno presenta vantaggi e svantaggi in termini di sicurezza. È consigliabile evitare di controllare eventuali informazioni riservate o di lasciare informazioni riservate nel codice nel contenitore.

Annotazioni

Quando viene distribuita in Azure, l'app Web ottiene le informazioni di connessione dai valori di ambiente impostati come impostazioni di configurazione del servizio app e nessuna delle modifiche per lo scenario dell'ambiente di sviluppo locale si applica.

Uso di VS Code

  1. Nella cartella .vscode dell'app di esempio, il file settings.json definisce cosa accade quando si usa l'estensione Docker e si seleziona Esegui o Esegui Interattivo dal menu di scelta rapida di un Tag. Il filesettings.json contiene due modelli ciascuno per gli (MongoDB local) scenari e (MongoDB Azure) .

    Screenshot che mostra il file settings.json in Visual Studio Code.

    Se si usa un database MongoDB locale:

    • Sostituisci entrambe le istanze di <YOUR_IP_ADDRESS> con l'indirizzo IP.

    • Sostituire entrambe le istanze di <CONNECTION_STRING> con la stringa di connessione per il database MongoDB.

    • Aggiungere la variabile di ambiente seguente alla stringa di variabili passate al comando docker run per i modelli locali mongoDB per i blocchi di codice "docker.commands.run" e "docker.commands.runInteractive":

      -e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'

    Se stai utilizzando un database di Azure Cosmos DB per MongoDB:

    • Sostituire entrambe le istanze di <CONNECTION_STRING> con la stringa di connessione di Azure Cosmos DB per MongoDB.

    • Aggiungere la variabile di ambiente seguente alla stringa di variabili passate al comando docker run per i modelli locali mongoDB per i blocchi di codice "docker.commands.run" e "docker.commands.runInteractive":

      -e 'SECRET_KEY=supersecretkeythatispassedtopythonapp'

  2. Impostare l'impostazione docker.dockerPath di configurazione usata dai modelli. Per impostare docker.dockerPath, aprire il riquadro comandi di VS Code (CTRL+MAIUSC+P), immettere "Preferenze: Apri impostazioni area di lavoro", quindi immettere "docker.dockerPath" nella casella Impostazioni di ricerca . Immettere "docker" (senza le virgolette) per il valore dell'impostazione.

    Annotazioni

    Si presuppone che sia il nome del database che il nome della raccolta siano restaurants_reviews.

  3. Avvia l'immagine.

    1. Nella sezione IMAGES dell'estensione Docker trovare l'immagine compilata.

    2. Espandere l'immagine per trovare il tag più recente , fare clic con il pulsante destro del mouse e selezionare Esegui interattivo.

    3. Viene richiesto di selezionare l'attività appropriata per lo scenario, ovvero "Configurazione di esecuzione interattiva (mongoDB locale)" o "Configurazione di esecuzione interattiva (Azure MongoDB)".

    Con un'esecuzione interattiva, vengono visualizzate tutte le istruzioni di stampa nel codice, che possono essere utili per il debug. È anche possibile selezionare Esegui, che non è interattivo e non mantiene aperto l'input standard.

    Screenshot che mostra come eseguire un contenitore Docker in Visual Studio Code.

    Importante

    Questo passaggio ha esito negativo se il profilo del terminale predefinito è impostato su (Windows) Prompt dei comandi. Per modificare il profilo predefinito, aprire il riquadro comandi di VS Code (CTRL+MAIUSC+P), immettere "Terminale: Seleziona profilo predefinito" e quindi selezionare un profilo diverso dal menu a discesa, ad esempio Git Bash o PowerShell.

  4. Verificare che il contenitore Docker sia in esecuzione.

    1. Nella sezione CONTENITORi dell'estensione Docker trovare il contenitore.

    2. Espandi il nodo Singoli contenitori e verifica che il contenitore "msdocspythoncontainerwebapp" sia in esecuzione. Cercare un simbolo di triangolo verde accanto al nome del contenitore.

    Screenshot che mostra come verificare che un contenitore Docker sia in esecuzione in Visual Studio Code.

  5. Testare l'app Web facendo clic con il pulsante destro del mouse sul nome del contenitore e scegliendo Apri nel browser.

    Screenshot che mostra come esplorare l'endpoint di un contenitore Docker in Visual Studio Code.

    Il browser si apre nel tuo browser predefinito come "http://127.0.0.1:8000" per Django o "http://127.0.0.1:5000/" per Flask.

  6. Fermare il contenitore.

    1. Nella sezione CONTENITORi dell'estensione Docker trovare il contenitore in esecuzione.

    2. Fare clic con il pulsante destro del mouse sul contenitore e scegliere Arresta.

    Screenshot che mostra come arrestare un contenitore Docker in esecuzione in Visual Studio Code.

Suggerimento

È anche possibile eseguire il contenitore selezionando una configurazione di esecuzione o debug. Le attività di estensione Docker in tasks.json vengono chiamate quando si eseguono le operazioni o il debug. L'attività chiamata dipende dalla configurazione di avvio selezionata. Per l'attività "Docker: Python (MongoDB locale)", specificare <YOUR-IP-ADDRESS>. Per l'attività "Docker: Python (MongoDB Azure)", specificare <CONNECTION-STRING>.

Utilizzo del Docker CLI

È possibile usare l'istanza locale di MongoDB o l'istanza di Azure Cosmos DB per MongoDB.

Uso dell'istanza locale di MongoDB

  1. Eseguire la versione più recente dell'immagine.

    #!/bin/bash

# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
export PORT=<port-number>  # Replace with actual port (e.g., 8000 or 5000)

# Set your computer''s IP address (replace with actual IP)
export YOUR_IP_ADDRESS=<your-computer-ip-address>  # Replace with actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it \
  --publish "$PORT:$PORT" \
  --publish 27017:27017 \
  --add-host "mongoservice:$YOUR_IP_ADDRESS" \
  --env CONNECTION_STRING=mongodb://mongoservice:27017 \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY="supersecretkeythatispassedtopythonapp" \
  msdocspythoncontainerwebapp:latest

    # PowerShell syntax
# Define variables
# Set the port number based on the framework being used:
# 8000 for Django, 5000 for Flask
$PORT = "your_port_number"  # Replace with your actual port number
$YOUR_IP_ADDRESS = "your_ip_address"  # Replace with your actual IP address

# Run the Docker container with the required environment variables
docker run --rm -it `
    --publish "${PORT}:${PORT}" `
    --publish 27017:27017 `
    --add-host "mongoservice:$YOUR_IP_ADDRESS" `
    --env CONNECTION_STRING="mongodb://mongoservice:27017" `
    --env DB_NAME="restaurants_reviews" `
    --env COLLECTION_NAME="restaurants_reviews" `
    --env SECRET_KEY="supersecretkeythatispassedtopythonapp" `
    msdocspythoncontainerwebapp:latest

    Uso dell'istanza di Azure Cosmos DB per MongoDB

    #!/bin/bash
# PORT=8000 for Django and 5000 for Flask
export PORT=<port-number>
export CONNECTION_STRING="<connection-string>"

docker run --rm -it \
  --publish $PORT:$PORT/tcp \
  --env CONNECTION_STRING=$CONNECTION_STRING \
  --env DB_NAME=restaurants_reviews \
  --env COLLECTION_NAME=restaurants_reviews \
  --env SECRET_KEY=supersecretkeythatyougenerate \
  msdocspythoncontainerwebapp:latest

    # PowerShell syntax
# PORT=8000 for Django and 5000 for Flask
$PORT=<port-number>
$ CONNECTION_STRING="<connection-string>"

docker run --rm -it `
  --publish $PORT:$PORT/tcp `
  --env CONNECTION_STRING=$CONNECTION_STRING `
  --env DB_NAME=restaurants_reviews `
  --env COLLECTION_NAME=restaurants_reviews `
  --env SECRET_KEY=supersecretkeythatyougenerate `
  msdocspythoncontainerwebapp:latest

    Il passaggio di informazioni riservate viene visualizzato solo a scopo dimostrativo. Le informazioni sulla stringa di connessione possono essere visualizzate esaminando il contenitore con il comando docker container inspect. Un altro modo per gestire i segreti consiste nell'usare la funzionalità BuildKit di Docker.

  2. Verificare che il contenitore sia in esecuzione. In un'altra finestra della console eseguire il comando ls del contenitore Docker .

    docker container ls

    Visualizza il contenitore "msdocspythoncontainerwebapp:latest:latest" nell'elenco. Si noti la NAMES colonna dell'output e la PORTS colonna. Utilizzare il nome del contenitore per arrestare il contenitore.

  3. Testare l'app Web.

    Vai a "http://127.0.0.1:8000" per Django e "http://127.0.0.1:5000/" per Flask.

  4. Spegnere il contenitore.

    docker container stop <container-name>

È anche possibile avviare un contenitore da un'immagine e arrestarlo con l'applicazione Docker Desktop .

Passaggio successivo

Creare un'immagine del contenitore in Azure