Apache-Proxy-Manager

1. Struttura del Progetto

proxy-manager/
├── backend/
│   ├── app/
│   │   ├── __init__.py
│   │   ├── models/
│   │   ├── routes/
│   │   ├── services/
│   │   └── utils/
│   ├── config.py
│   ├── requirements.txt
│   └── wsgi.py
├── frontend/
│   ├── public/
│   ├── src/
│   │   ├── components/
│   │   ├── services/
│   │   ├── utils/
│   │   └── App.tsx
│   ├── package.json
│   └── vite.config.ts
└── docker-compose.yml

2. Backend - Nuovi File Necessari

config.py

import os
from datetime import timedelta

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or os.urandom(24)
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
        'postgresql://postgres:postgres@localhost/proxy_manager'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    
    # JWT Settings
    JWT_SECRET_KEY = os.environ.get('JWT_SECRET_KEY') or os.urandom(24)
    JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=1)
    
    # SSL Settings
    SSL_CERT_DIR = os.environ.get('CERT_DIR') or '/opt/proxy-manager/certs'
    SSL_KEY_DIR = os.environ.get('KEY_DIR') or '/opt/proxy-manager/keys'
    
    # Proxy Settings
    PROXY_CHECK_INTERVAL = 60  # seconds
    STATS_COLLECTION_INTERVAL = 300  # seconds

requirements.txt

Flask==2.3.3
Flask-SQLAlchemy==3.1.1
Flask-Login==0.6.2
Flask-JWT-Extended==4.5.2
Flask-Cors==4.0.0
psycopg2-binary==2.9.9
python-dotenv==1.0.0
schedule==1.2.0
pyOpenSSL==23.2.0
gunicorn==21.2.0
certbot==2.7.4

3. Frontend - Nuovi File Necessari

src/services/api.ts

import axios from 'axios';

const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:5000';

const api = axios.create({
    baseURL: API_URL,
    headers: {
        'Content-Type': 'application/json'
    }
});

// Add token to requests
api.interceptors.request.use((config) => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
});

export const auth = {
    login: (username: string, password: string) => 
        api.post('/auth/login', { username, password }),
    logout: () => api.post('/auth/logout')
};

export const proxies = {
    getAll: () => api.get('/api/proxy'),
    create: (data: any) => api.post('/api/proxy', data),
    update: (id: number, data: any) => api.put(`/api/proxy/${id}`, data),
    delete: (id: number) => api.delete(`/api/proxy/${id}`),
    getHealth: (id: number) => api.get(`/api/proxy/${id}/health`)
};

export const stats = {
    getTraffic: (days: number = 7) => 
        api.get('/api/access-logs', { params: { days } })
};

export default api;

package.json

{
  "name": "proxy-manager-frontend",
  "private": true,
  "version": "0.1.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "axios": "^1.6.2",
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "recharts": "^2.10.3",
    "lucide-react": "^0.263.1",
    "tailwindcss": "^3.3.0",
    "@types/react": "^18.2.0",
    "@types/react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^4.2.0",
    "typescript": "^5.0.0",
    "vite": "^5.0.0"
  }
}

4. Docker Setup

docker-compose.yml

version: '3.8'

services:
  backend:
    build: ./backend
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db/proxy_manager
      - SECRET_KEY=your-secret-key-here
      - JWT_SECRET_KEY=your-jwt-secret-here
    volumes:
      - ./certs:/opt/proxy-manager/certs
      - ./keys:/opt/proxy-manager/keys
    depends_on:
      - db

  frontend:
    build: ./frontend
    ports:
      - "3000:80"
    environment:
      - VITE_API_URL=http://localhost:5000
    depends_on:
      - backend

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=proxy_manager
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5. Guida all'Installazione e Avvio

Prerequisiti

• Docker e Docker Compose
• Node.js 18+ (per sviluppo locale)
• Python 3.9+ (per sviluppo locale)
• PostgreSQL (per sviluppo locale)

Sviluppo Locale

1. Setup Backend

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
# o
.\venv\Scripts\activate  # Windows

# Install dependencies
cd backend
pip install -r requirements.txt

# Set environment variables
export FLASK_APP=wsgi.py
export FLASK_ENV=development
export DATABASE_URL=postgresql://postgres:postgres@localhost/proxy_manager

# Initialize database
flask db upgrade

# Run backend
flask run

2. Setup Frontend

cd frontend
npm install
npm run dev

Utilizzo con Docker

1. Preparazione

# Create necessary directories
mkdir -p certs keys

# Copy environment files
cp backend/.env.example backend/.env
cp frontend/.env.example frontend/.env

2. Avvio

docker-compose up -d

3. Accesso

• Frontend: http://localhost:3000
• Backend API: http://localhost:5000

4. Account Default

Username: admin
Password: admin123

6. Funzionalità Principali

1. Gestione Proxy

   • Creazione e gestione di proxy inversi
   • Monitoraggio dello stato in tempo reale
   • Statistiche di traffico

2. Gestione SSL

   • Generazione automatica certificati SSL
   • Rinnovo automatico Let's Encrypt
   • Monitoraggio scadenze

3. Monitoraggio

   • Dashboard in tempo reale
   • Grafici di traffico
   • Logs di accesso

4. Gestione Utenti

   • Autenticazione JWT
   • Gestione ruoli (admin/user)
   • Audit logging

7. Note di Sicurezza

1. Cambiare immediatamente le password default
2. Utilizzare chiavi segrete sicure in produzione
3. Configurare correttamente i permessi delle directory dei certificati
4. Abilitare HTTPS in produzione
5. Configurare correttamente CORS in produzione

8. Manutenzione

1. Backup Database

docker-compose exec db pg_dump -U postgres proxy_manager > backup.sql

2. Aggiornamento

docker-compose pull
docker-compose up -d --build

3. Logs

docker-compose logs -f