Guida CompletaProgetti Didattici

# Scansiona la rete per trovare il Raspberry (sostituisci 192.168.1 con la tua subnet)
nmap -sn 192.168.1.0/24 | grep -A1 "Raspberry"

# Oppure, se conosci il suo hostname:
ping raspberry-lab.local

# Una volta trovato l'IP, connettiti via SSH:
ssh pi@192.168.1.X

# Windows: usa PuTTY oppure il terminale di Windows 11
# Inserisci la password che hai scelto durante la configurazione

# Aggiorna la lista dei pacchetti disponibili dai repository
sudo apt update

# Aggiorna tutti i pacchetti installati all'ultima versione disponibile
sudo apt upgrade -y

# Aggiorna anche i pacchetti del firmware e del kernel
sudo apt full-upgrade -y

# Rimuovi pacchetti obsoleti non più necessari
sudo apt autoremove -y

# Pulisci la cache locale dei pacchetti scaricati
sudo apt autoclean

# Riavvia il sistema (necessario dopo aggiornamenti del kernel)
sudo reboot

# Mostra le connessioni di rete attive e il nome dell'interfaccia
nmcli connection show

# Di solito la connessione ethernet si chiama "Wired connection 1"
# Imposta IP statico (adatta i valori alla tua rete scolastica)
sudo nmcli connection modify "Wired connection 1" \
  ipv4.addresses 192.168.1.200/24 \
  ipv4.gateway 192.168.1.1 \
  ipv4.dns "8.8.8.8,8.8.4.4" \
  ipv4.method manual

# Applica le modifiche riavviando la connessione
sudo nmcli connection down "Wired connection 1"
sudo nmcli connection up "Wired connection 1"

# Verifica il nuovo IP assegnato
ip addr show eth0

# Installa tutti i tool essenziali in una sola riga
sudo apt install -y \
  curl wget git nano htop \
  net-tools nmap ufw fail2ban \
  python3 python3-pip python3-venv \
  ca-certificates gnupg lsb-release \
  unzip zip tree jq

# Verifica le versioni installate
python3 --version   # es: Python 3.11.x
git --version       # es: git version 2.39.x
curl --version      # es: curl 7.88.x

# Imposta la policy di default: blocca tutto il traffico in entrata
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Permetti SSH (porta 22) — FONDAMENTALE: fallo PRIMA di attivare UFW
sudo ufw allow 22/tcp

# Permetti HTTP e HTTPS
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Attiva il firewall (rispondo "y" alla conferma)
sudo ufw enable

# Controlla lo stato e le regole attive
sudo ufw status verbose

# Rimuovi eventuali versioni vecchie di Docker
sudo apt remove -y docker docker-engine docker.io containerd runc 2>/dev/null

# Aggiungi la chiave GPG ufficiale di Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Aggiungi il repository Docker ai sorgenti apt
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Aggiorna i repository e installa Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# Aggiungi l'utente corrente al gruppo docker (evita sudo ogni volta)
sudo usermod -aG docker $USER

# Applica il cambio di gruppo SUBITO (senza riavviare la sessione SSH)
newgrp docker

# Verifica le versioni installate
docker --version
docker compose version

# Verifica che il servizio Docker sia attivo
sudo systemctl status docker

# Crea la cartella principale del progetto
mkdir -p ~/nextcloud
cd ~/nextcloud

# Crea le directory che verranno montate come volumi Docker
mkdir -p data/nextcloud   # file di Nextcloud (config, app)
mkdir -p data/mariadb     # database MariaDB
mkdir -p data/userfiles   # file caricati dagli utenti

# Crea il file per le variabili d'ambiente (password separate dal compose)
nano .env

# === PASSWORD DATABASE ===
MYSQL_ROOT_PASSWORD=RootPassSicura2024!
MYSQL_DATABASE=nextcloud
MYSQL_USER=nextcloud_user
MYSQL_PASSWORD=NcDbPass2024!

# === ADMIN NEXTCLOUD ===
NEXTCLOUD_ADMIN_USER=admin
NEXTCLOUD_ADMIN_PASSWORD=AdminPass2024!

# === DOMINIO (usa l'IP del Raspberry se non hai un dominio)
NEXTCLOUD_TRUSTED_DOMAINS=192.168.1.200

nano ~/nextcloud/docker-compose.yml

version: '3.8'

services:

  # === DATABASE MariaDB ===
  db:
    image: mariadb:10.11
    container_name: nextcloud-db
    restart: always
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes:
      # I dati del DB vengono salvati qui sul SSD (persistono anche se il container si riavvia)
      - ./data/mariadb:/var/lib/mysql
    networks:
      - nextcloud-net
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

  # === CACHE REDIS ===
  redis:
    image: redis:7-alpine
    container_name: nextcloud-redis
    restart: always
    command: redis-server --requirepass nextcloudredis123
    networks:
      - nextcloud-net

  # === APPLICAZIONE NEXTCLOUD ===
  nextcloud:
    image: nextcloud:28-apache
    container_name: nextcloud-app
    restart: always
    ports:
      - "8080:80"   # espone Nextcloud sulla porta 8080 del Raspberry
    environment:
      MYSQL_HOST: db
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
      REDIS_HOST: redis
      REDIS_HOST_PASSWORD: nextcloudredis123
      NEXTCLOUD_ADMIN_USER: ${NEXTCLOUD_ADMIN_USER}
      NEXTCLOUD_ADMIN_PASSWORD: ${NEXTCLOUD_ADMIN_PASSWORD}
      NEXTCLOUD_TRUSTED_DOMAINS: ${NEXTCLOUD_TRUSTED_DOMAINS}
      PHP_MEMORY_LIMIT: 512M
      PHP_UPLOAD_LIMIT: 2G
    volumes:
      - ./data/nextcloud:/var/www/html          # core di Nextcloud
      - ./data/userfiles:/var/www/html/data     # file degli utenti
    networks:
      - nextcloud-net
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started

networks:
  nextcloud-net:
    driver: bridge

# Vai nella cartella del progetto
cd ~/nextcloud

# Avvia tutto in background (-d = detached mode)
docker compose up -d

# Osserva i log in tempo reale (Ctrl+C per uscire senza fermare i container)
docker compose logs -f

# Controlla che tutti e 3 i container siano "Up"
docker compose ps

# Controlla lo stato dettagliato
docker compose ps --format "table {{.Name}}\t{{.Status}}\t{{.Ports}}"

# Installa Nginx
sudo apt install -y nginx

# Crea il file di configurazione per Nextcloud
sudo nano /etc/nginx/sites-available/nextcloud

server {
    listen 80;
    server_name 192.168.1.200;  # o il tuo dominio

    # Aumenta la dimensione massima dei file caricabili
    client_max_body_size 2G;

    # Header di sicurezza
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "no-referrer" always;

    location / {
        proxy_pass http://127.0.0.1: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;

        # Timeout per upload file grandi
        proxy_connect_timeout 300;
        proxy_send_timeout 300;
        proxy_read_timeout 300;

        # Disabilita il buffering per i download
        proxy_buffering off;
    }
}

# Abilita il sito creando un link simbolico
sudo ln -s /etc/nginx/sites-available/nextcloud /etc/nginx/sites-enabled/

# Rimuovi il sito di default di Nginx
sudo rm -f /etc/nginx/sites-enabled/default

# Testa la configurazione (deve rispondere "syntax is ok")
sudo nginx -t

# Applica la configurazione
sudo systemctl reload nginx

# Apri la porta 80 nel firewall
sudo ufw allow 80/tcp

# Scarica ed esegui lo script di installazione ufficiale
curl -fsSL https://ollama.com/install.sh | sh

# Lo script installa Ollama come servizio systemd
# Verifica che il servizio sia partito
sudo systemctl status ollama

# Verifica che risponda sulla porta 11434
curl http://localhost:11434
# Risposta attesa: "Ollama is running"

# Controlla la versione installata
ollama --version

# Scarica Mistral 7B (raccomandato per il laboratorio — buona qualità)
ollama pull mistral

# Oppure Llama3.2 3B (più veloce, consuma meno RAM)
ollama pull llama3.2:3b

# Vedi tutti i modelli scaricati con la loro dimensione
ollama list

# Test rapido: esegui il modello nel terminale
# Scrivi una domanda e premi Invio — Ctrl+D per uscire
ollama run mistral "Spiega il subnetting in 3 righe"

# Controlla quanta RAM sta usando durante l'inferenza
watch -n 1 free -h

# Crea un override per il servizio systemd di Ollama
sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo nano /etc/systemd/system/ollama.service.d/override.conf

[Service]
# Ascolta su tutte le interfacce di rete (non solo localhost)
Environment="OLLAMA_HOST=0.0.0.0:11434"
# Numero massimo di richieste parallele (una per studente)
Environment="OLLAMA_NUM_PARALLEL=2"
# Mantieni il modello in RAM per 10 minuti dopo l'uso
Environment="OLLAMA_KEEP_ALIVE=10m"

# Ricarica la configurazione systemd
sudo systemctl daemon-reload

# Riavvia Ollama con le nuove impostazioni
sudo systemctl restart ollama

# Apri la porta nel firewall per la rete locale
sudo ufw allow from 192.168.1.0/24 to any port 11434

# Verifica che Ollama risponda da un altro PC della rete:
curl http://192.168.1.200:11434/api/tags

# Installa Apache2
sudo apt install -y apache2

# Avvialo e abilita l'avvio automatico al boot
sudo systemctl start apache2
sudo systemctl enable apache2

# Controlla che sia in esecuzione
sudo systemctl status apache2

# Apri la porta 80 nel firewall (già aperta se hai fatto il progetto 1)
sudo ufw allow 80/tcp

# Test: deve rispondere con "It works!" (pagina di default Apache)
curl http://localhost
# Oppure apri il browser su http://192.168.1.200

# Abilita i moduli Apache necessari
sudo a2enmod rewrite   # URL rewriting
sudo a2enmod headers   # gestione header HTTP
sudo a2enmod userdir   # cartelle utente (~utente)
sudo systemctl restart apache2

# Installa le dipendenze per GNS3
sudo apt install -y \
  python3-pip python3-venv \
  qemu-kvm \
  libvirt-daemon-system \
  bridge-utils \
  ubridge \
  wireshark \
  tshark

# Installa GNS3 server via pip in un virtualenv isolato
python3 -m venv ~/gns3-venv
source ~/gns3-venv/bin/activate
pip install gns3-server gns3-webclient

# Aggiungi l'utente al gruppo necessario per cattura pacchetti
sudo usermod -aG wireshark $USER
sudo usermod -aG kvm $USER
sudo usermod -aG ubridge $USER

# Applica i gruppi (richiede logout/login o riavvio)
sudo reboot