scontrini

Gestione scontrini d'acquisto prodotti nei vari supermercati ed altro.

scontrini/ │ ├── app.py # Punto di ingresso principale (Backend) ├── models.py # Classi Database (User, Prodotto, Prezzo) ├── import_data.py # Script utility per importazione CSV ├── requirements.txt # Dipendenze (Flask, SQLAlchemy, Pandas, Gunicorn) ├── Dockerfile # Configurazione Container ├── docker-compose.yml # Orchestrazione (Porte, Volumi) ├── .env # Variabili segrete (SECRET_KEY) │ ├── static/ # Risorse statiche │ ├── css/ │ │ └── style.css # [GENERATO SOPRA] │ ├── js/ │ │ └── scanner.js # [GENERATO SOPRA] │ ├── images/ │ │ ├── icon-192.png # (Da aggiungere: immagine 192x192) │ │ └── icon-512.png # (Da aggiungere: immagine 512x512) │ └── manifest.json # Configurazione PWA │ ├── templates/ # Template HTML │ ├── base.html # [GENERATO SOPRA] │ ├── index.html # Scanner View │ ├── login.html # Form Accesso │ └── dashboard.html # Statistiche Prezzi │ └── instance/ # Database └── spesa.db # (Creato automaticamente da Flask)

Far girare questa applicazione su un server con Docker è un processo lineare, ma richiede precisione nella gestione dei volumi e della rete per assicurarsi che i dati non vadano persi e che il proxy comunichi correttamente con il container.

Ecco i passi da seguire, partendo dal presupposto che tu abbia già i file pronti sul tuo computer locale.

1. Preparazione della cartella sul Server

Accedi al tuo server via SSH e crea una cartella dedicata al progetto. Bash

mkdir smart-spesa && cd smart-spesa mkdir -p instance static/images static/css static/js templates

2. Trasferimento dei file

Copia i file che abbiamo generato nelle rispettive posizioni. Puoi usare scp, rsync o semplicemente creare i file con un editor di testo come nano o vim.

La struttura finale sul server deve essere:

/scontrini/app.py

/scontrini/models.py

/scontrini/requirements.txt

/scontrini/Dockerfile

/scontrini/docker-compose.yml

/scontrini/.env

/scontrini/static/manifest.json (e le altre sottocartelle static)

/scontrini/templates/ (tutti i file .html)

3. Configurazione dell'ambiente (.env)

Crea il file .env per gestire la sicurezza: Bash

SECRET_KEY=una_stringa_molto_lunga_e_casuale DATABASE_URL=sqlite:///instance/spesa.db

4. Build e Avvio dei Container

Dalla cartella principale del progetto (/smart-spesa), esegui il comando per costruire l'immagine e avviare il servizio in background: Bash

docker-compose up -d --build

Cosa succede ora:

Docker scarica l'immagine di Python.

Installa le dipendenze da requirements.txt.

Avvia Gunicorn sulla porta interna 5000.

Mappa la porta 8080 del tuo server alla 5000 del container (come definito nel docker-compose.yml).

5. Verifica del funzionamento

Controlla che il container sia attivo: Bash

docker ps

Dovresti vedere il container spesa_tracker in stato "Up". Puoi anche leggere i log per vedere se Flask è partito correttamente: Bash

docker logs -f spesa_tracker

6. Configurazione del Proxy Esterno

Dato che il tuo proxy (Nginx o Apache) si trova su un host separato, devi configurarlo per puntare all'IP del server Docker.

Esempio per Nginx sul server Proxy: Nginx

location / { proxy_pass http://IP_DEL_SERVER_DOCKER:8080; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; }

IMPORTANTE: Assicurati che il firewall del server Docker permetta il traffico in entrata sulla porta 8080 solo dall'IP del tuo Proxy Server per massimizzare la sicurezza.

7. Creazione dell'utente Admin

Una volta che l'app è attiva, devi creare il primo utente per poter accedere. Esegui questo comando direttamente nel container: Bash

docker exec -it spesa_tracker flask create-admin

(Assumendo che tu abbia inserito il comando @app.cli.command("create-admin") in app.py come discusso in precedenza). Riassunto comandi rapidi per manutenzione:

Fermare l'app: docker-compose down

Aggiornare il codice: Dopo aver modificato i file, esegui di nuovo docker-compose up -d --build.

Backup del database: Ti basta copiare il file che trovi nella cartella locale ./instance/spesa.db. Essendo un volume montato, i dati sopravvivono anche se cancelli il container.

L'applicazione è ora raggiungibile tramite il tuo dominio configurato sul proxy! Hai già configurato i certificati SSL sul tuo proxy server? (Necessari, come ricordato, per far funzionare la fotocamera).

La SECRET_KEY in Flask è fondamentale per la sicurezza: viene utilizzata per firmare i cookie delle sessioni e prevenire la manipolazione dei dati da parte degli utenti. In un ambiente Docker, non va mai scritta direttamente nel codice, ma passata come variabile d'ambiente.

Ecco i modi più rapidi e sicuri per generarne una professionale.

1. Metodo consigliato (Tramite Python)

Il modo più semplice è utilizzare il modulo nativo secrets di Python, che genera stringhe casuali sicure per crittografia.

Esegui questo comando nel tuo terminale (sul tuo PC o sul server): Bash

python3 -c 'import secrets; print(secrets.token_hex(32))'

Risultato tipico:

7d9f2b8a1c3e4d5b6a7f8e9d0c1b2a3f4e5d6c7b8a9f0e1d2c3b4a5f6e7d8c9

2. Metodo alternativo (Tramite Terminale Linux)

Se non vuoi usare Python, puoi generare una chiave robusta usando openssl: Bash

openssl rand -hex 32

3. Dove inserire la chiave generata?

Una volta ottenuta la stringa, devi inserirla nel file .env che abbiamo creato nella cartella del progetto sul server:

File .env Plaintext

SECRET_KEY=7d9f2b8a1c3e4d5b6a7f8e9d0c1b2a3f4e5d6c7b8a9f0e1d2c3b4a5f6e7d8c9 DATABASE_URL=sqlite:///instance/spesa.db

E assicurati che nel tuo file app.py la chiave venga letta correttamente: