# Navigate to your existing InfraWatch repository from Day 1
cd InfraWatch

# Create backend directory structure
mkdir -p backend/{app/{api,core,models,services},tests/{unit,integration},config}
mkdir -p backend/app/{api/v1,static,templates}

# Install Python version manager (if not already installed)
curl https://pyenv.run | bash

# Install Python 3.11 (production-stable version)
pyenv install 3.11.0
pyenv local 3.11.0

# Create virtual environment (isolation principle)
python -m venv backend/venv
source backend/venv/bin/activate  # On Windows: backendvenvScriptsactivate

## Step 2: Project Structure Creation

Create the foundational files that define your application architecture.  
This structure mirrors production-grade backend systems and prepares the project for scalability and modular development.

### Create Core Application Files

from flask import Flask
from app.core.config import Config
from app.api.v1 import health_bp, infrastructure_bp

def create_app(config_class=Config):
    """Application factory pattern - enables testing and multiple configurations"""
    app = Flask(__name__)
    app.config.from_object(config_class)
    
    # Register blueprints (modular architecture)
    app.register_blueprint(health_bp, url_prefix='/api/v1')
    app.register_blueprint(infrastructure_bp, url_prefix='/api/v1')
    
    return app
#Configuration management (environment-specific settings):

# backend/app/core/config.py
import os
from datetime import timedelta

class Config:
    """Production-ready configuration management"""
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key-change-in-production'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'sqlite:///infrawatch.db'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    
    # Production performance settings
    SQLALCHEMY_ENGINE_OPTIONS = {
        'pool_pre_ping': True,
        'pool_recycle': 300,
    }
    
    # API versioning and rate limiting
    API_VERSION = 'v1'
    RATE_LIMIT_ENABLED = True

class DevelopmentConfig(Config):
    DEBUG = True

class ProductionConfig(Config):
    DEBUG = False
    # Additional production-specific settings would go here

class TestingConfig(Config):
    TESTING = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'

#Infrastructure monitoring models (domain-driven design):

# backend/app/models/infrastructure.py
from datetime import datetime
from dataclasses import dataclass
from typing import Dict, List, Optional

@dataclass
class Server:
    """Represents a monitored server in our infrastructure"""
    id: str
    hostname: str
    ip_address: str
    status: str  # 'healthy', 'warning', 'critical'
    cpu_usage: float
    memory_usage: float
    disk_usage: float
    last_heartbeat: datetime
    
    def to_dict(self) -> Dict:
        """Serialize for API responses"""
        return {
            'id': self.id,
            'hostname': self.hostname,
            'ip_address': self.ip_address,
            'status': self.status,
            'metrics': {
                'cpu_usage': self.cpu_usage,
                'memory_usage': self.memory_usage,
                'disk_usage': self.disk_usage
            },
            'last_heartbeat': self.last_heartbeat.isoformat()
        }

@dataclass
class InfrastructureCluster:
    """Represents a cluster of servers (like a Kubernetes cluster)"""
    name: str
    servers: List[Server]
    
    @property
    def healthy_servers(self) -> int:
        return len([s for s in self.servers if s.status == 'healthy'])
    
    @property
    def total_servers(self) -> int:
        return len(self.servers)

#API endpoints using Blueprint pattern (microservice-ready architecture):

# backend/app/api/v1/__init__.py
from flask import Blueprint, jsonify, request
from app.models.infrastructure import Server, InfrastructureCluster
from datetime import datetime, timedelta
import random

health_bp = Blueprint('health', __name__)
infrastructure_bp = Blueprint('infrastructure', __name__)

@health_bp.route('/health')
def health_check():
    """Health endpoint - critical for load balancers and monitoring"""
    return jsonify({
        'status': 'healthy',
        'timestamp': datetime.utcnow().isoformat(),
        'version': '1.0.0',
        'service': 'infrawatch-backend'
    })

@infrastructure_bp.route('/servers')
def get_servers():
    """Get all monitored servers - simulates real infrastructure data"""
    # In production, this would query your database
    mock_servers = [
        Server(
            id=f'server-{i}',
            hostname=f'web-{i}.example.com',
            ip_address=f'10.0.1.{i+10}',
            status=random.choice(['healthy', 'warning', 'critical']),
            cpu_usage=random.uniform(10, 90),
            memory_usage=random.uniform(20, 80),
            disk_usage=random.uniform(30, 70),
            last_heartbeat=datetime.utcnow() - timedelta(seconds=random.randint(0, 300))
        ) for i in range(5)
    ]
    
    return jsonify({
        'servers': [server.to_dict() for server in mock_servers],
        'total_count': len(mock_servers),
        'timestamp': datetime.utcnow().isoformat()
    })

@infrastructure_bp.route('/clusters')
def get_clusters():
    """Get infrastructure clusters overview"""
    # Simulate cluster data
    servers = [
        Server(f'node-{i}', f'k8s-node-{i}', f'10.0.2.{i+10}', 
               'healthy', 45.2, 60.1, 35.8, datetime.utcnow())
        for i in range(3)
    ]
    
    cluster = InfrastructureCluster('production-cluster', servers)
    
    return jsonify({
        'cluster_name': cluster.name,
        'total_servers': cluster.total_servers,
        'healthy_servers': cluster.healthy_servers,
        'servers': [server.to_dict() for server in cluster.servers]
    })

#Application entry point: 

# backend/run.py
from app import create_app

app = create_app()

if __name__ == '__main__':
    # Development server - never use in production
    app.run(host='0.0.0.0', port=5000, debug=True) 

#Dependencies management:
# backend/requirements.txt
Flask==2.3.3
Flask-SQLAlchemy==3.0.5
python-dotenv==1.0.0
gunicorn==21.2.0
# backend/requirements-dev.txt
-r requirements.txt
pytest==7.4.2
pytest-cov==4.1.0
black==23.7.0
flake8==6.0.0

#Environment configuration:
# backend/.env.example
SECRET_KEY=your-secret-key-here
DATABASE_URL=sqlite:///infrawatch.db
FLASK_ENV=development
FLASK_DEBUG=1

#Step 4: Containerization for Production Deployment

#Production Docker configuration:

# backend/Dockerfile
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y 
    gcc 
    && rm -rf /var/lib/apt/lists/*

# Copy requirements first (Docker layer caching optimization)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Create non-root user (security best practice)
RUN useradd --create-home --shell /bin/bash app
RUN chown -R app:app /app
USER app

# Expose port
EXPOSE 5000

# Production command
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "run:app"]

#Docker Compose for development:

# backend/docker-compose.yml
version: '3.8'

services:
  backend:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=development
      - DATABASE_URL=sqlite:///infrawatch.db
    volumes:
      - .:/app
    command: python run.py
    
  # Future services (database, redis, etc.) will be added here

#Step 5: Building and Testing

Install dependencies and run locally:

# Activate virtual environment
source backend/venv/bin/activate

# Install dependencies
pip install -r backend/requirements.txt
pip install -r backend/requirements-dev.txt

# Set environment variables
cp backend/.env.example backend/.env

# Run locally
cd backend
python run.py

#Build and run with Docker:

# Build Docker image
cd backend
docker build -t infrawatch-backend .

# Run container
docker run -p 5000:5000 infrawatch-backend

# Or use Docker Compose (recommended)
docker-compose up --build

#Step 6: Testing Your Implementation

Verify your backend is working by testing these endpoints:

# Health check
curl http://localhost:5000/api/v1/health

# Get servers data
curl http://localhost:5000/api/v1/servers

# Get clusters data
curl http://localhost:5000/api/v1/clusters