🌐 Configuring Network Function Virtualization on Alpine Linux: Modern Networking

Let’s implement Network Function Virtualization (NFV) on Alpine Linux to transform traditional network functions into virtualized services! 🚀 This comprehensive tutorial shows you how to set up virtual network functions, orchestration, and service chaining using containers and modern virtualization technologies. Perfect for network engineers building software-defined infrastructure! 😊

🤔 What is Network Function Virtualization?

Network Function Virtualization (NFV) is a network architecture approach that virtualizes network services traditionally provided by dedicated hardware appliances, enabling them to run as software on commodity servers using containers or virtual machines!

NFV is like:

• 🏗️ Modular construction where network functions are building blocks you can arrange dynamically
• 🎭 Theater stage where different network services can perform their roles on the same hardware
• 🔧 Swiss Army knife that transforms generic hardware into any network function you need

🎯 What You Need

Before we start, you need:

• ✅ Alpine Linux system with virtualization support and adequate resources
• ✅ Understanding of networking concepts, containers, and virtualization
• ✅ Knowledge of software-defined networking (SDN) principles
• ✅ Root access and network configuration capabilities

📋 Step 1: Install NFV Foundation Components

Install Containerization and Orchestration

Let’s set up the container-based NFV foundation! 😊

What we’re doing: Installing Docker, Kubernetes, and essential tools for running virtualized network functions in containers.

# Update package list
apk update

# Install containerization platform
apk add docker docker-compose docker-cli-compose
apk add containerd

# Install container networking tools
apk add bridge-utils iptables ebtables
apk add iproute2 net-tools ethtool

# Install Kubernetes for orchestration
apk add kubectl

# Install OpenVSwitch for SDN
apk add openvswitch openvswitch-dev

# Install DPDK for high-performance networking
apk add dpdk dpdk-dev

# Install network monitoring tools
apk add tcpdump wireshark-common
apk add iperf3 nload

# Install virtualization tools
apk add qemu-img qemu-system-x86_64
apk add libvirt libvirt-daemon

# Enable and start Docker
rc-update add docker default
service docker start

# Enable Docker for current user
adduser $USER docker
newgrp docker

# Verify installations
docker --version
kubectl version --client
ovs-vsctl --version

echo "NFV foundation installed! 🏗️"

What this does: 📖 Installs complete containerization and networking stack for NFV implementation.

Example output:

Docker version 24.0.7, build afdd53b
Client Version: v1.28.4
ovs-vsctl (Open vSwitch) 3.2.1
NFV foundation installed! 🏗️

What this means: Alpine Linux is ready for NFV deployment! ✅

Configure Open vSwitch SDN Infrastructure

Let’s set up software-defined networking! 🎯

What we’re doing: Configuring Open vSwitch for creating virtual networks and managing traffic flows between virtualized network functions.

# Enable and start Open vSwitch
rc-update add openvswitch default
service openvswitch start

# Create OVS database
ovsdb-tool create /etc/openvswitch/ovs-vswitchd.conf.db /usr/share/openvswitch/vswitch.ovsschema

# Start OVS services
ovsdb-server --remote=punix:/var/run/openvswitch/db.sock \
             --remote=db:Open_vSwitch,Open_vSwitch,manager_options \
             --private-key=db:Open_vSwitch,SSL,private_key \
             --certificate=db:Open_vSwitch,SSL,certificate \
             --bootstrap-ca-cert=db:Open_vSwitch,SSL,ca_cert \
             --pidfile --detach

ovs-vswitchd --pidfile --detach

# Create virtual switches for NFV
ovs-vsctl add-br nfv-mgmt    # Management network
ovs-vsctl add-br nfv-data    # Data plane network
ovs-vsctl add-br nfv-control # Control plane network

# Configure network interfaces
ovs-vsctl add-port nfv-mgmt eth0
ovs-vsctl add-port nfv-data eth1

# Set up VLAN tagging for network isolation
ovs-vsctl set port nfv-mgmt tag=100  # Management VLAN
ovs-vsctl set port nfv-data tag=200  # Data VLAN

# Create OpenFlow controller connection
ovs-vsctl set-controller nfv-data tcp:127.0.0.1:6653

# Configure QoS for traffic management
ovs-vsctl set port nfv-data qos=@newqos -- \
    --id=@newqos create qos type=linux-htb \
    other-config:max-rate=1000000000

# Verify OVS configuration
ovs-vsctl show
ovs-vsctl list-br

echo "Open vSwitch SDN configured! 🌐"

What this does: 📖 Sets up software-defined networking infrastructure for NFV service chaining.

Example output:

Bridge nfv-control
Bridge nfv-data
    Port eth1
        Interface eth1
    Controller "tcp:127.0.0.1:6653"
Bridge nfv-mgmt
    Port eth0
        Interface eth0
        tag: 100
Open vSwitch SDN configured! 🌐

What this means: SDN infrastructure is ready for virtual network functions! ✅

📋 Step 2: Deploy Virtual Network Functions

Create Virtual Firewall Function

Let’s implement a containerized firewall VNF! 😊

What we’re doing: Creating a virtual firewall network function using containers with iptables and advanced packet filtering capabilities.

# Create virtual firewall directory
mkdir -p /opt/vnf/firewall
cd /opt/vnf/firewall

# Create Dockerfile for firewall VNF
cat > Dockerfile << 'EOF'
# Virtual Firewall Network Function
FROM alpine:3.19

# Install firewall and networking tools
RUN apk add --no-cache \
    iptables \
    ip6tables \
    ipset \
    conntrack-tools \
    tcpdump \
    netcat-openbsd \
    curl \
    bash

# Create firewall configuration directory
RUN mkdir -p /etc/firewall

# Copy firewall scripts
COPY firewall-rules.sh /usr/local/bin/
COPY firewall-monitor.sh /usr/local/bin/
COPY entrypoint.sh /usr/local/bin/

# Make scripts executable
RUN chmod +x /usr/local/bin/*.sh

# Expose management interface
EXPOSE 8080

# Set entrypoint
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
CMD ["firewall"]
EOF

# Create firewall rules script
cat > firewall-rules.sh << 'EOF'
#!/bin/bash

# Virtual Firewall Rules Configuration
set -e

# Enable IP forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv6/conf/all/forwarding

# Clear existing rules
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X

# Set default policies
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# Allow loopback traffic
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

# Allow established and related connections
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# Allow management interface
iptables -A INPUT -p tcp --dport 8080 -j ACCEPT

# Create custom chains for VNF processing
iptables -N VNF_INPUT
iptables -N VNF_FORWARD
iptables -N VNF_OUTPUT

# Advanced security rules
iptables -A VNF_INPUT -p tcp --syn -m limit --limit 1/s --limit-burst 3 -j ACCEPT
iptables -A VNF_INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j ACCEPT

# DDoS protection
iptables -A VNF_INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT
iptables -A VNF_INPUT -p tcp --dport 443 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT

# Geographic blocking (example)
iptables -A VNF_INPUT -m geoip --src-cc CN,RU -j DROP

# Application layer filtering
iptables -A VNF_FORWARD -p tcp --dport 80 -m string --string "malware" --algo bm -j DROP
iptables -A VNF_FORWARD -p tcp --dport 443 -m string --string "malicious" --algo bm -j DROP

# Link custom chains
iptables -A INPUT -j VNF_INPUT
iptables -A FORWARD -j VNF_FORWARD
iptables -A OUTPUT -j VNF_OUTPUT

echo "Virtual firewall rules applied successfully"
EOF

# Create firewall monitoring script
cat > firewall-monitor.sh << 'EOF'
#!/bin/bash

# Virtual Firewall Monitoring Script
LOG_FILE="/var/log/firewall-monitor.log"

log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Monitor connection statistics
monitor_connections() {
    CONNECTIONS=$(conntrack -C 2>/dev/null || echo "0")
    log_message "Active connections: $CONNECTIONS"
    
    # Check for connection limits
    if [ "$CONNECTIONS" -gt 10000 ]; then
        log_message "WARNING: High connection count detected"
    fi
}

# Monitor firewall rules
monitor_rules() {
    DROPPED=$(iptables -L INPUT -n -v | grep DROP | awk '{sum += $1} END {print sum}')
    ACCEPTED=$(iptables -L INPUT -n -v | grep ACCEPT | awk '{sum += $1} END {print sum}')
    
    log_message "Packets dropped: ${DROPPED:-0}, accepted: ${ACCEPTED:-0}"
}

# Monitor system resources
monitor_resources() {
    CPU=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/%us,//')
    MEM=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100}')
    
    log_message "CPU: ${CPU}%, Memory: ${MEM}%"
}

# Main monitoring loop
while true; do
    monitor_connections
    monitor_rules
    monitor_resources
    sleep 60
done
EOF

# Create entrypoint script
cat > entrypoint.sh << 'EOF'
#!/bin/bash

# Virtual Firewall VNF Entrypoint
set -e

case "$1" in
    firewall)
        echo "Starting Virtual Firewall VNF..."
        
        # Apply firewall rules
        /usr/local/bin/firewall-rules.sh
        
        # Start monitoring in background
        /usr/local/bin/firewall-monitor.sh &
        
        # Start management API
        while true; do
            echo -e "HTTP/1.1 200 OK\n\nVirtual Firewall VNF - Status: Active" | nc -l -p 8080
        done
        ;;
    *)
        exec "$@"
        ;;
esac
EOF

# Build firewall VNF container
docker build -t vnf-firewall:latest .

# Create Docker Compose for firewall VNF
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  vnf-firewall:
    image: vnf-firewall:latest
    container_name: vnf-firewall
    privileged: true
    network_mode: host
    cap_add:
      - NET_ADMIN
      - NET_RAW
      - SYS_ADMIN
    volumes:
      - /var/log:/var/log
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
    environment:
      - VNF_ID=firewall-001
      - VNF_TYPE=firewall
    restart: unless-stopped
    labels:
      - "vnf.type=firewall"
      - "vnf.version=1.0"
EOF

echo "Virtual Firewall VNF created! 🔥"

What this does: 📖 Creates a containerized virtual firewall with advanced security features and monitoring.

Example output:

Successfully built vnf-firewall:latest
Virtual Firewall VNF created! 🔥

What this means: Virtual firewall network function is ready for deployment! ✅

Create Virtual Load Balancer Function

Let’s implement a load balancer VNF! 🎯

What we’re doing: Creating a virtual load balancer network function using HAProxy in containers for traffic distribution and failover.

# Create virtual load balancer directory
mkdir -p /opt/vnf/loadbalancer
cd /opt/vnf/loadbalancer

# Create Dockerfile for load balancer VNF
cat > Dockerfile << 'EOF'
# Virtual Load Balancer Network Function
FROM alpine:3.19

# Install HAProxy and tools
RUN apk add --no-cache \
    haproxy \
    curl \
    socat \
    bash \
    jq \
    python3 \
    py3-requests

# Create configuration directories
RUN mkdir -p /etc/haproxy /var/lib/haproxy /var/log/haproxy

# Copy configuration files
COPY haproxy.cfg /etc/haproxy/
COPY lb-manager.py /usr/local/bin/
COPY entrypoint.sh /usr/local/bin/

# Make scripts executable
RUN chmod +x /usr/local/bin/*.py /usr/local/bin/entrypoint.sh

# Create haproxy user
RUN adduser -D -s /sbin/nologin haproxy

# Expose ports
EXPOSE 80 443 8404 9999

# Set entrypoint
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
CMD ["loadbalancer"]
EOF

# Create HAProxy configuration
cat > haproxy.cfg << 'EOF'
# Virtual Load Balancer Configuration
global
    daemon
    user haproxy
    group haproxy
    log stdout local0
    
    # Performance tuning
    tune.ssl.default-dh-param 2048
    tune.bufsize 32768
    tune.maxrewrite 1024
    
    # Stats socket for API
    stats socket /var/run/haproxy/admin.sock mode 660 level admin
    stats timeout 30s

defaults
    mode http
    log global
    option httplog
    option dontlognull
    option log-health-checks
    option forwardfor
    option redispatch
    
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms
    timeout check 10s
    
    default-server inter 3s fall 3 rise 2

# Statistics interface
frontend stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 30s
    stats hide-version
    stats auth admin:vnf-lb-2024

# HTTP frontend
frontend http_frontend
    bind *:80
    
    # Rate limiting
    stick-table type ip size 100k expire 30s store http_req_rate(10s)
    http-request track-sc0 src
    http-request reject if { sc_http_req_rate(0) gt 20 }
    
    # Load balancing algorithms
    default_backend web_servers

# HTTPS frontend  
frontend https_frontend
    bind *:443 ssl crt /etc/ssl/certs/vnf-lb.pem
    
    # HSTS and security headers
    http-response set-header Strict-Transport-Security "max-age=31536000; includeSubDomains"
    http-response set-header X-Frame-Options DENY
    http-response set-header X-Content-Type-Options nosniff
    
    default_backend web_servers

# Dynamic backend configuration
backend web_servers
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    
    # Cookie-based session persistence
    cookie SERVERID insert indirect nocache
    
    # Default backend servers (will be updated dynamically)
    server web1 192.168.1.10:80 check cookie web1 weight 100
    server web2 192.168.1.11:80 check cookie web2 weight 100
    server web3 192.168.1.12:80 check cookie web3 weight 50 backup

# TCP mode for database connections
frontend db_frontend
    bind *:3306
    mode tcp
    default_backend db_servers

backend db_servers
    mode tcp
    balance leastconn
    option tcp-check
    tcp-check connect port 3306
    
    server db1 192.168.1.20:3306 check weight 100
    server db2 192.168.1.21:3306 check weight 100 backup

# API gateway
frontend api_frontend
    bind *:8080
    
    # API rate limiting
    stick-table type ip size 100k expire 30s store http_req_rate(10s)
    http-request track-sc0 src
    http-request reject if { sc_http_req_rate(0) gt 100 }
    
    # API versioning
    acl api_v1 path_beg /api/v1
    acl api_v2 path_beg /api/v2
    
    use_backend api_v1_servers if api_v1
    use_backend api_v2_servers if api_v2
    default_backend api_v2_servers

backend api_v1_servers
    balance roundrobin
    option httpchk GET /api/v1/health
    server api1 192.168.1.30:8080 check weight 100
    server api2 192.168.1.31:8080 check weight 100

backend api_v2_servers
    balance roundrobin
    option httpchk GET /api/v2/health
    server api1 192.168.1.32:8080 check weight 100
    server api2 192.168.1.33:8080 check weight 100
EOF

# Create load balancer manager script
cat > lb-manager.py << 'EOF'
#!/usr/bin/env python3

# Virtual Load Balancer Manager
import json
import socket
import time
import threading
import http.server
import socketserver
from urllib.parse import urlparse, parse_qs

class LoadBalancerManager:
    def __init__(self):
        self.haproxy_socket = '/var/run/haproxy/admin.sock'
        self.servers = {}
        
    def send_command(self, command):
        """Send command to HAProxy via stats socket"""
        try:
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            sock.connect(self.haproxy_socket)
            sock.send(f"{command}\n".encode())
            response = sock.recv(4096).decode()
            sock.close()
            return response
        except Exception as e:
            return f"Error: {e}"
    
    def add_server(self, backend, server_name, address, weight=100):
        """Add server to backend"""
        command = f"add server {backend}/{server_name} {address} weight {weight}"
        return self.send_command(command)
    
    def remove_server(self, backend, server_name):
        """Remove server from backend"""
        command = f"del server {backend}/{server_name}"
        return self.send_command(command)
    
    def enable_server(self, backend, server_name):
        """Enable server in backend"""
        command = f"enable server {backend}/{server_name}"
        return self.send_command(command)
    
    def disable_server(self, backend, server_name):
        """Disable server in backend"""
        command = f"disable server {backend}/{server_name}"
        return self.send_command(command)
    
    def get_stats(self):
        """Get HAProxy statistics"""
        response = self.send_command("show stat")
        return response
    
    def health_check(self):
        """Perform health checks on servers"""
        stats = self.get_stats()
        lines = stats.split('\n')
        
        for line in lines[1:]:  # Skip header
            if line.strip():
                fields = line.split(',')
                if len(fields) > 17:
                    backend = fields[0]
                    server = fields[1]
                    status = fields[17]
                    
                    if status == 'DOWN' and server != 'BACKEND':
                        print(f"Server {backend}/{server} is DOWN")

class APIHandler(http.server.BaseHTTPRequestHandler):
    def __init__(self, lb_manager, *args, **kwargs):
        self.lb_manager = lb_manager
        super().__init__(*args, **kwargs)
    
    def do_GET(self):
        """Handle GET requests"""
        if self.path == '/health':
            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            response = {'status': 'healthy', 'type': 'loadbalancer'}
            self.wfile.write(json.dumps(response).encode())
            
        elif self.path == '/stats':
            self.send_response(200)
            self.send_header('Content-type', 'text/plain')
            self.end_headers()
            stats = self.lb_manager.get_stats()
            self.wfile.write(stats.encode())
            
        else:
            self.send_response(404)
            self.end_headers()
    
    def do_POST(self):
        """Handle POST requests for server management"""
        if self.path.startswith('/server'):
            content_length = int(self.headers['Content-Length'])
            post_data = self.rfile.read(content_length)
            data = json.loads(post_data.decode())
            
            action = data.get('action')
            backend = data.get('backend')
            server = data.get('server')
            address = data.get('address')
            
            if action == 'add':
                result = self.lb_manager.add_server(backend, server, address)
            elif action == 'remove':
                result = self.lb_manager.remove_server(backend, server)
            elif action == 'enable':
                result = self.lb_manager.enable_server(backend, server)
            elif action == 'disable':
                result = self.lb_manager.disable_server(backend, server)
            else:
                result = "Invalid action"
            
            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            response = {'result': result}
            self.wfile.write(json.dumps(response).encode())

def start_api_server(lb_manager):
    """Start API server for load balancer management"""
    handler = lambda *args, **kwargs: APIHandler(lb_manager, *args, **kwargs)
    
    with socketserver.TCPServer(("", 9999), handler) as httpd:
        print("Load Balancer API server started on port 9999")
        httpd.serve_forever()

def main():
    lb_manager = LoadBalancerManager()
    
    # Start API server in background
    api_thread = threading.Thread(target=start_api_server, args=(lb_manager,))
    api_thread.daemon = True
    api_thread.start()
    
    # Start health check loop
    while True:
        lb_manager.health_check()
        time.sleep(30)

if __name__ == '__main__':
    main()
EOF

# Create entrypoint script
cat > entrypoint.sh << 'EOF'
#!/bin/bash

# Virtual Load Balancer VNF Entrypoint
set -e

case "$1" in
    loadbalancer)
        echo "Starting Virtual Load Balancer VNF..."
        
        # Create required directories
        mkdir -p /var/run/haproxy /var/lib/haproxy
        chown haproxy:haproxy /var/run/haproxy /var/lib/haproxy
        
        # Generate SSL certificate for HTTPS
        if [ ! -f /etc/ssl/certs/vnf-lb.pem ]; then
            openssl req -x509 -newkey rsa:2048 -keyout /tmp/key.pem -out /tmp/cert.pem \
                -days 365 -nodes -subj "/C=US/ST=State/L=City/O=VNF/CN=vnf-lb.local"
            cat /tmp/cert.pem /tmp/key.pem > /etc/ssl/certs/vnf-lb.pem
            chmod 600 /etc/ssl/certs/vnf-lb.pem
        fi
        
        # Start HAProxy
        haproxy -f /etc/haproxy/haproxy.cfg &
        
        # Start load balancer manager
        python3 /usr/local/bin/lb-manager.py
        ;;
    *)
        exec "$@"
        ;;
esac
EOF

# Build load balancer VNF container
docker build -t vnf-loadbalancer:latest .

echo "Virtual Load Balancer VNF created! ⚖️"

What this does: 📖 Creates a sophisticated virtual load balancer with dynamic configuration and API management.

Example output:

Successfully built vnf-loadbalancer:latest
Virtual Load Balancer VNF created! ⚖️

What this means: Virtual load balancer network function is ready for traffic distribution! ✅

📋 Step 3: Implement NFV Orchestration

Set Up VNF Lifecycle Management

Let’s create NFV orchestration system! 😊

What we’re doing: Implementing VNF lifecycle management with automated deployment, scaling, and service chaining capabilities.

# Create NFV orchestrator directory
mkdir -p /opt/nfv-orchestrator
cd /opt/nfv-orchestrator

# Create VNF descriptor templates
mkdir -p templates/vnfd

# Create firewall VNF descriptor
cat > templates/vnfd/firewall-vnfd.yaml << 'EOF'
# Virtual Network Function Descriptor - Firewall
vnfd:
  id: firewall-vnf
  name: "Virtual Firewall"
  description: "Containerized firewall VNF with advanced security features"
  version: "1.0"
  
  # VNF configuration
  vnf-configuration:
    config-type: "script"
    config-details:
      script-type: "bash"
      
  # Virtual deployment units
  vdu:
    - id: firewall-vdu
      name: "Firewall Container"
      image: "vnf-firewall:latest"
      count: 1
      
      # Resource requirements
      vm-flavor:
        vcpu-count: 2
        memory-mb: 2048
        storage-gb: 10
      
      # Network interfaces
      interface:
        - name: "mgmt"
          type: "management"
          virtual-interface:
            type: "VIRTIO"
        - name: "data-in"
          type: "internal"
          virtual-interface:
            type: "VIRTIO"
        - name: "data-out"
          type: "internal"
          virtual-interface:
            type: "VIRTIO"
      
      # Monitoring parameters
      monitoring-param:
        - id: "cpu-utilization"
          name: "CPU Utilization"
          aggregation-type: "AVERAGE"
        - id: "memory-utilization"
          name: "Memory Utilization"
          aggregation-type: "AVERAGE"
        - id: "packet-throughput"
          name: "Packet Throughput"
          aggregation-type: "AVERAGE"

  # Connection points
  connection-point:
    - name: "firewall-mgmt"
      type: "VPORT"
    - name: "firewall-input"
      type: "VPORT"
    - name: "firewall-output"
      type: "VPORT"

  # Scaling aspects
  scaling-group-descriptor:
    - name: "firewall-scaling"
      min-instance-count: 1
      max-instance-count: 5
      scaling-policy:
        - name: "cpu-scale-out"
          scaling-type: "automatic"
          threshold-time: 60
          cooldown-time: 300
          scaling-criteria:
            - name: "cpu-threshold"
              scale-out-threshold: 80
              scale-in-threshold: 20
EOF

# Create load balancer VNF descriptor
cat > templates/vnfd/loadbalancer-vnfd.yaml << 'EOF'
# Virtual Network Function Descriptor - Load Balancer
vnfd:
  id: loadbalancer-vnf
  name: "Virtual Load Balancer"
  description: "High-performance load balancer VNF with API management"
  version: "1.0"
  
  # VNF configuration
  vnf-configuration:
    config-type: "api"
    config-details:
      api-endpoint: "http://localhost:9999"
      
  # Virtual deployment units
  vdu:
    - id: loadbalancer-vdu
      name: "Load Balancer Container"
      image: "vnf-loadbalancer:latest"
      count: 1
      
      # Resource requirements
      vm-flavor:
        vcpu-count: 4
        memory-mb: 4096
        storage-gb: 20
      
      # Network interfaces
      interface:
        - name: "mgmt"
          type: "management"
        - name: "frontend"
          type: "external"
        - name: "backend"
          type: "internal"
      
      # Exposed ports
      ports:
        - name: "http"
          port: 80
          protocol: "TCP"
        - name: "https"
          port: 443
          protocol: "TCP"
        - name: "api"
          port: 9999
          protocol: "TCP"

  # Connection points
  connection-point:
    - name: "lb-mgmt"
      type: "VPORT"
    - name: "lb-frontend"
      type: "VPORT"
    - name: "lb-backend"
      type: "VPORT"

  # Performance requirements
  performance-requirements:
    - name: "throughput"
      value: "10Gbps"
    - name: "latency"
      value: "1ms"
    - name: "availability"
      value: "99.99%"
EOF

# Create NFV orchestrator script
cat > nfv-orchestrator.py << 'EOF'
#!/usr/bin/env python3

# NFV Orchestrator for VNF Lifecycle Management
import json
import yaml
import docker
import subprocess
import time
import threading
from datetime import datetime

class NFVOrchestrator:
    def __init__(self):
        self.docker_client = docker.from_env()
        self.vnfs = {}
        self.service_chains = {}
        
    def load_vnfd(self, vnfd_file):
        """Load VNF descriptor from file"""
        with open(vnfd_file, 'r') as f:
            return yaml.safe_load(f)
    
    def deploy_vnf(self, vnfd, instance_name):
        """Deploy VNF instance based on descriptor"""
        print(f"Deploying VNF: {instance_name}")
        
        vnf_config = vnfd['vnfd']
        vdu = vnf_config['vdu'][0]  # Assuming single VDU for simplicity
        
        # Create container configuration
        container_config = {
            'image': vdu['image'],
            'name': instance_name,
            'detach': True,
            'privileged': True,
            'network_mode': 'host',
            'labels': {
                'vnf.type': vnf_config['id'],
                'vnf.name': vnf_config['name'],
                'vnf.version': vnf_config['version']
            },
            'environment': {
                'VNF_ID': instance_name,
                'VNF_TYPE': vnf_config['id']
            }
        }
        
        # Add resource constraints
        flavor = vdu.get('vm-flavor', {})
        if 'memory-mb' in flavor:
            container_config['mem_limit'] = f"{flavor['memory-mb']}m"
        if 'vcpu-count' in flavor:
            container_config['cpu_count'] = flavor['vcpu-count']
        
        try:
            container = self.docker_client.containers.run(**container_config)
            
            self.vnfs[instance_name] = {
                'container': container,
                'vnfd': vnfd,
                'status': 'running',
                'deployed_at': datetime.now()
            }
            
            print(f"VNF {instance_name} deployed successfully")
            return True
            
        except Exception as e:
            print(f"Failed to deploy VNF {instance_name}: {e}")
            return False
    
    def terminate_vnf(self, instance_name):
        """Terminate VNF instance"""
        if instance_name in self.vnfs:
            try:
                container = self.vnfs[instance_name]['container']
                container.stop()
                container.remove()
                
                del self.vnfs[instance_name]
                print(f"VNF {instance_name} terminated successfully")
                return True
                
            except Exception as e:
                print(f"Failed to terminate VNF {instance_name}: {e}")
                return False
        return False
    
    def scale_vnf(self, vnf_type, action, count=1):
        """Scale VNF instances up or down"""
        if action == 'scale-out':
            for i in range(count):
                instance_name = f"{vnf_type}-{int(time.time())}-{i}"
                vnfd_file = f"templates/vnfd/{vnf_type}-vnfd.yaml"
                vnfd = self.load_vnfd(vnfd_file)
                self.deploy_vnf(vnfd, instance_name)
                
        elif action == 'scale-in':
            vnf_instances = [name for name in self.vnfs.keys() if vnf_type in name]
            for i in range(min(count, len(vnf_instances))):
                self.terminate_vnf(vnf_instances[i])
    
    def create_service_chain(self, chain_name, vnf_sequence):
        """Create service function chain"""
        print(f"Creating service chain: {chain_name}")
        
        # Create OVS flows for service chaining
        for i, vnf_name in enumerate(vnf_sequence):
            if i < len(vnf_sequence) - 1:
                next_vnf = vnf_sequence[i + 1]
                
                # Create flow rule to chain VNFs
                flow_cmd = f"""
                ovs-ofctl add-flow nfv-data "priority=100,
                in_port={i+1},
                actions=output:{i+2}"
                """
                subprocess.run(flow_cmd, shell=True)
        
        self.service_chains[chain_name] = {
            'sequence': vnf_sequence,
            'created_at': datetime.now(),
            'status': 'active'
        }
        
        print(f"Service chain {chain_name} created successfully")
    
    def monitor_vnfs(self):
        """Monitor VNF health and performance"""
        while True:
            for name, vnf_info in self.vnfs.items():
                try:
                    container = vnf_info['container']
                    container.reload()
                    
                    # Get container stats
                    stats = container.stats(stream=False)
                    
                    # Calculate CPU usage
                    cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - \
                               stats['precpu_stats']['cpu_usage']['total_usage']
                    system_delta = stats['cpu_stats']['system_cpu_usage'] - \
                                  stats['precpu_stats']['system_cpu_usage']
                    
                    if system_delta > 0:
                        cpu_percent = (cpu_delta / system_delta) * 100
                    else:
                        cpu_percent = 0
                    
                    # Calculate memory usage
                    memory_usage = stats['memory_stats']['usage']
                    memory_limit = stats['memory_stats']['limit']
                    memory_percent = (memory_usage / memory_limit) * 100
                    
                    print(f"VNF {name}: CPU: {cpu_percent:.2f}%, Memory: {memory_percent:.2f}%")
                    
                    # Check scaling thresholds
                    if cpu_percent > 80:
                        print(f"High CPU usage detected for {name}, considering scale-out")
                    elif cpu_percent < 20:
                        print(f"Low CPU usage detected for {name}, considering scale-in")
                    
                except Exception as e:
                    print(f"Error monitoring VNF {name}: {e}")
            
            time.sleep(60)
    
    def get_status(self):
        """Get orchestrator status"""
        status = {
            'vnfs': len(self.vnfs),
            'service_chains': len(self.service_chains),
            'running_vnfs': []
        }
        
        for name, vnf_info in self.vnfs.items():
            status['running_vnfs'].append({
                'name': name,
                'type': vnf_info['vnfd']['vnfd']['id'],
                'status': vnf_info['status'],
                'deployed_at': vnf_info['deployed_at'].isoformat()
            })
        
        return status

def main():
    orchestrator = NFVOrchestrator()
    
    # Start monitoring thread
    monitor_thread = threading.Thread(target=orchestrator.monitor_vnfs)
    monitor_thread.daemon = True
    monitor_thread.start()
    
    # Deploy sample VNFs
    print("Deploying sample VNF infrastructure...")
    
    # Deploy firewall VNF
    firewall_vnfd = orchestrator.load_vnfd('templates/vnfd/firewall-vnfd.yaml')
    orchestrator.deploy_vnf(firewall_vnfd, 'firewall-001')
    
    # Deploy load balancer VNF
    lb_vnfd = orchestrator.load_vnfd('templates/vnfd/loadbalancer-vnfd.yaml')
    orchestrator.deploy_vnf(lb_vnfd, 'loadbalancer-001')
    
    # Create service chain
    orchestrator.create_service_chain('web-security-chain', 
                                    ['firewall-001', 'loadbalancer-001'])
    
    # Keep orchestrator running
    while True:
        status = orchestrator.get_status()
        print(f"NFV Orchestrator Status: {json.dumps(status, indent=2)}")
        time.sleep(300)  # Status update every 5 minutes

if __name__ == '__main__':
    main()
EOF

chmod +x nfv-orchestrator.py

# Install Python dependencies
apk add py3-pip
pip3 install docker pyyaml

echo "NFV Orchestration system configured! 🎭"

What this does: 📖 Creates comprehensive VNF lifecycle management with automated deployment and scaling.

Example output:

NFV Orchestration system configured! 🎭

What this means: Complete NFV orchestration is ready for managing virtual network functions! ✅

📋 Step 4: Configure Service Function Chaining

Implement Traffic Steering and SFC

Let’s set up advanced service chaining! 🎯

What we’re doing: Implementing Service Function Chaining (SFC) with traffic steering, policy enforcement, and automated service composition.

# Create service function chaining directory
mkdir -p /opt/sfc-controller
cd /opt/sfc-controller

# Create SFC controller script
cat > sfc-controller.py << 'EOF'
#!/usr/bin/env python3

# Service Function Chaining Controller
import json
import subprocess
import time
import threading
from dataclasses import dataclass
from typing import List, Dict, Any

@dataclass
class ServiceFunction:
    name: str
    sf_type: str
    mgmt_ip: str
    data_plane_locator: str
    
@dataclass
class ServicePath:
    path_id: int
    service_functions: List[str]
    classifier_rules: Dict[str, Any]

class SFCController:
    def __init__(self):
        self.service_functions = {}
        self.service_paths = {}
        self.flow_rules = {}
        
    def register_sf(self, sf: ServiceFunction):
        """Register a service function"""
        self.service_functions[sf.name] = sf
        print(f"Registered service function: {sf.name} ({sf.sf_type})")
    
    def create_service_path(self, path: ServicePath):
        """Create service function path"""
        self.service_paths[path.path_id] = path
        
        # Generate OpenFlow rules for service chaining
        self._generate_flow_rules(path)
        
        print(f"Created service path {path.path_id} with {len(path.service_functions)} functions")
    
    def _generate_flow_rules(self, path: ServicePath):
        """Generate OpenFlow rules for service path"""
        path_id = path.path_id
        
        # Create flow rules for each hop in the service chain
        for i, sf_name in enumerate(path.service_functions):
            if sf_name not in self.service_functions:
                print(f"Warning: Service function {sf_name} not registered")
                continue
                
            sf = self.service_functions[sf_name]
            
            # Input flow rule
            in_port = i + 10  # Start from port 10
            out_port = i + 11
            
            # Classification rules for first SF in chain
            if i == 0:
                classifier = path.classifier_rules
                match_fields = []
                
                if 'src_ip' in classifier:
                    match_fields.append(f"nw_src={classifier['src_ip']}")
                if 'dst_ip' in classifier:
                    match_fields.append(f"nw_dst={classifier['dst_ip']}")
                if 'protocol' in classifier:
                    match_fields.append(f"nw_proto={classifier['protocol']}")
                if 'src_port' in classifier:
                    match_fields.append(f"tp_src={classifier['src_port']}")
                if 'dst_port' in classifier:
                    match_fields.append(f"tp_dst={classifier['dst_port']}")
                
                match_str = ",".join(match_fields) if match_fields else "dl_type=0x0800"
                
                flow_rule = f"""
                ovs-ofctl add-flow nfv-data "table=0,priority=100,
                {match_str},
                actions=set_field:{path_id}->reg0,
                output:{in_port}"
                """
            else:
                # Inter-SF flow rules
                flow_rule = f"""
                ovs-ofctl add-flow nfv-data "table=0,priority=100,
                reg0={path_id},in_port={in_port},
                actions=output:{out_port}"
                """
            
            # Store and apply flow rule
            rule_id = f"path_{path_id}_sf_{i}"
            self.flow_rules[rule_id] = flow_rule.strip()
            
            # Apply the flow rule
            subprocess.run(flow_rule, shell=True, capture_output=True)
            
        # Final output rule (last SF to destination)
        if path.service_functions:
            final_port = len(path.service_functions) + 10
            final_rule = f"""
            ovs-ofctl add-flow nfv-data "table=0,priority=100,
            reg0={path_id},in_port={final_port},
            actions=normal"
            """
            
            rule_id = f"path_{path_id}_output"
            self.flow_rules[rule_id] = final_rule.strip()
            subprocess.run(final_rule, shell=True, capture_output=True)
    
    def delete_service_path(self, path_id: int):
        """Delete service function path"""
        if path_id in self.service_paths:
            # Remove associated flow rules
            rules_to_remove = [rule_id for rule_id in self.flow_rules.keys() 
                             if f"path_{path_id}" in rule_id]
            
            for rule_id in rules_to_remove:
                # Convert add-flow to del-flows command
                del_cmd = self.flow_rules[rule_id].replace("add-flow", "del-flows")
                subprocess.run(del_cmd, shell=True, capture_output=True)
                del self.flow_rules[rule_id]
            
            del self.service_paths[path_id]
            print(f"Deleted service path {path_id}")
    
    def get_path_statistics(self, path_id: int):
        """Get statistics for service path"""
        if path_id not in self.service_paths:
            return None
        
        stats = {
            'path_id': path_id,
            'service_functions': self.service_paths[path_id].service_functions,
            'flow_stats': []
        }
        
        # Get flow statistics from OVS
        cmd = f"ovs-ofctl dump-flows nfv-data | grep reg0={path_id}"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        
        for line in result.stdout.split('\n'):
            if line.strip():
                # Parse flow statistics
                if 'n_packets=' in line and 'n_bytes=' in line:
                    parts = line.split(',')
                    for part in parts:
                        if 'n_packets=' in part:
                            packets = part.split('=')[1]
                            stats['flow_stats'].append({'packets': int(packets)})
        
        return stats
    
    def update_path_policy(self, path_id: int, new_policy: Dict[str, Any]):
        """Update service path policy"""
        if path_id in self.service_paths:
            path = self.service_paths[path_id]
            
            # Update classifier rules
            if 'classifier_rules' in new_policy:
                path.classifier_rules.update(new_policy['classifier_rules'])
                
                # Regenerate flow rules
                self.delete_service_path(path_id)
                self.create_service_path(path)
                
                print(f"Updated policy for service path {path_id}")

class SFCPolicyManager:
    def __init__(self, sfc_controller: SFCController):
        self.controller = sfc_controller
        self.policies = {}
    
    def create_policy(self, policy_name: str, policy_config: Dict[str, Any]):
        """Create traffic steering policy"""
        self.policies[policy_name] = policy_config
        
        # Apply policy by creating service paths
        for path_config in policy_config.get('service_paths', []):
            path = ServicePath(
                path_id=path_config['path_id'],
                service_functions=path_config['service_functions'],
                classifier_rules=path_config['classifier_rules']
            )
            self.controller.create_service_path(path)
        
        print(f"Applied policy: {policy_name}")
    
    def delete_policy(self, policy_name: str):
        """Delete traffic steering policy"""
        if policy_name in self.policies:
            policy_config = self.policies[policy_name]
            
            # Remove associated service paths
            for path_config in policy_config.get('service_paths', []):
                self.controller.delete_service_path(path_config['path_id'])
            
            del self.policies[policy_name]
            print(f"Deleted policy: {policy_name}")

def create_sample_configuration():
    """Create sample SFC configuration"""
    controller = SFCController()
    policy_manager = SFCPolicyManager(controller)
    
    # Register service functions
    firewall_sf = ServiceFunction(
        name="firewall-001",
        sf_type="firewall",
        mgmt_ip="192.168.1.100",
        data_plane_locator="192.168.1.100:6633"
    )
    
    lb_sf = ServiceFunction(
        name="loadbalancer-001", 
        sf_type="load-balancer",
        mgmt_ip="192.168.1.101",
        data_plane_locator="192.168.1.101:6633"
    )
    
    controller.register_sf(firewall_sf)
    controller.register_sf(lb_sf)
    
    # Create sample policies
    web_security_policy = {
        'description': 'Web traffic security policy',
        'service_paths': [
            {
                'path_id': 1,
                'service_functions': ['firewall-001', 'loadbalancer-001'],
                'classifier_rules': {
                    'protocol': 6,  # TCP
                    'dst_port': 80  # HTTP
                }
            },
            {
                'path_id': 2,
                'service_functions': ['firewall-001', 'loadbalancer-001'],
                'classifier_rules': {
                    'protocol': 6,  # TCP
                    'dst_port': 443  # HTTPS
                }
            }
        ]
    }
    
    database_policy = {
        'description': 'Database access policy with security',
        'service_paths': [
            {
                'path_id': 3,
                'service_functions': ['firewall-001'],
                'classifier_rules': {
                    'protocol': 6,  # TCP
                    'dst_port': 3306  # MySQL
                }
            }
        ]
    }
    
    policy_manager.create_policy('web-security', web_security_policy)
    policy_manager.create_policy('database-security', database_policy)
    
    return controller, policy_manager

def monitor_sfc_performance(controller: SFCController):
    """Monitor SFC performance metrics"""
    while True:
        print("=== SFC Performance Report ===")
        
        for path_id in controller.service_paths.keys():
            stats = controller.get_path_statistics(path_id)
            if stats:
                print(f"Service Path {path_id}:")
                print(f"  Functions: {' -> '.join(stats['service_functions'])}")
                print(f"  Flow Statistics: {stats['flow_stats']}")
        
        print("=" * 30)
        time.sleep(120)  # Report every 2 minutes

def main():
    print("Starting Service Function Chaining Controller...")
    
    # Create SFC configuration
    controller, policy_manager = create_sample_configuration()
    
    # Start performance monitoring
    monitor_thread = threading.Thread(target=monitor_sfc_performance, args=(controller,))
    monitor_thread.daemon = True
    monitor_thread.start()
    
    print("SFC Controller is running. Service paths configured:")
    for path_id, path in controller.service_paths.items():
        print(f"  Path {path_id}: {' -> '.join(path.service_functions)}")
    
    # Keep controller running
    try:
        while True:
            time.sleep(60)
    except KeyboardInterrupt:
        print("Shutting down SFC Controller...")

if __name__ == '__main__':
    main()
EOF

chmod +x sfc-controller.py

# Create SFC deployment script
cat > deploy-sfc.sh << 'EOF'
#!/bin/bash

# Service Function Chaining Deployment Script
set -e

echo "🌐 Deploying Service Function Chaining..."

# Ensure OVS is running
service openvswitch start

# Clear existing flows
ovs-ofctl del-flows nfv-data

# Configure OpenFlow tables for SFC
ovs-ofctl add-flow nfv-data "table=0,priority=0,actions=normal"

# Start VNFs using orchestrator
echo "Starting VNF instances..."
cd /opt/nfv-orchestrator
python3 nfv-orchestrator.py &
NFV_PID=$!

# Wait for VNFs to start
sleep 30

# Start SFC controller
echo "Starting SFC Controller..."
cd /opt/sfc-controller
python3 sfc-controller.py &
SFC_PID=$!

# Create cleanup script
cat > cleanup-sfc.sh << 'EOL'
#!/bin/bash
echo "Cleaning up SFC deployment..."
kill $NFV_PID $SFC_PID 2>/dev/null || true
ovs-ofctl del-flows nfv-data
docker stop $(docker ps -q --filter "label=vnf.type") 2>/dev/null || true
docker rm $(docker ps -aq --filter "label=vnf.type") 2>/dev/null || true
EOL

chmod +x cleanup-sfc.sh

echo "✅ Service Function Chaining deployed successfully!"
echo "SFC Controller PID: $SFC_PID"
echo "NFV Orchestrator PID: $NFV_PID"
echo "Use ./cleanup-sfc.sh to stop all services"
EOF

chmod +x deploy-sfc.sh

echo "Service Function Chaining configured! 🔗"

What this does: 📖 Implements advanced service function chaining with traffic steering and policy management.

Example output:

Service Function Chaining configured! 🔗

What this means: Complete SFC system is ready for automated service composition! ✅

📋 Step 5: Monitoring and Performance Optimization

Set Up NFV Monitoring Stack

Let’s implement comprehensive monitoring! 😊

What we’re doing: Setting up monitoring and analytics for NFV infrastructure with performance metrics, alerting, and optimization recommendations.

# Create NFV monitoring directory
mkdir -p /opt/nfv-monitoring
cd /opt/nfv-monitoring

# Install monitoring tools
apk add prometheus grafana
apk add node-exporter telegraf

# Create NFV metrics collector
cat > nfv-metrics-collector.py << 'EOF'
#!/usr/bin/env python3

# NFV Metrics Collector
import json
import time
import psutil
import docker
import subprocess
import threading
from prometheus_client import start_http_server, Gauge, Counter, Histogram
from datetime import datetime

# Prometheus metrics
vnf_cpu_usage = Gauge('vnf_cpu_usage_percent', 'VNF CPU Usage', ['vnf_name', 'vnf_type'])
vnf_memory_usage = Gauge('vnf_memory_usage_bytes', 'VNF Memory Usage', ['vnf_name', 'vnf_type'])
vnf_network_rx_bytes = Counter('vnf_network_rx_bytes_total', 'VNF Network RX Bytes', ['vnf_name', 'vnf_type'])
vnf_network_tx_bytes = Counter('vnf_network_tx_bytes_total', 'VNF Network TX Bytes', ['vnf_name', 'vnf_type'])
sfc_path_packets = Counter('sfc_path_packets_total', 'SFC Path Packets', ['path_id'])
sfc_path_latency = Histogram('sfc_path_latency_seconds', 'SFC Path Latency', ['path_id'])

class NFVMonitor:
    def __init__(self):
        self.docker_client = docker.from_env()
        self.vnf_metrics = {}
        
    def collect_vnf_metrics(self):
        """Collect VNF performance metrics"""
        try:
            # Get all VNF containers
            vnf_containers = self.docker_client.containers.list(
                filters={'label': 'vnf.type'}
            )
            
            for container in vnf_containers:
                vnf_name = container.name
                vnf_type = container.labels.get('vnf.type', 'unknown')
                
                # Get container stats
                stats = container.stats(stream=False)
                
                # Calculate CPU usage
                cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - \
                           stats['precpu_stats']['cpu_usage']['total_usage']
                system_delta = stats['cpu_stats']['system_cpu_usage'] - \
                              stats['precpu_stats']['system_cpu_usage']
                
                cpu_percent = 0
                if system_delta > 0 and cpu_delta > 0:
                    cpu_percent = (cpu_delta / system_delta) * 100
                
                # Memory usage
                memory_usage = stats['memory_stats'].get('usage', 0)
                
                # Network statistics
                network_stats = stats.get('networks', {})
                rx_bytes = sum(net['rx_bytes'] for net in network_stats.values())
                tx_bytes = sum(net['tx_bytes'] for net in network_stats.values())
                
                # Update Prometheus metrics
                vnf_cpu_usage.labels(vnf_name=vnf_name, vnf_type=vnf_type).set(cpu_percent)
                vnf_memory_usage.labels(vnf_name=vnf_name, vnf_type=vnf_type).set(memory_usage)
                vnf_network_rx_bytes.labels(vnf_name=vnf_name, vnf_type=vnf_type)._value._value = rx_bytes
                vnf_network_tx_bytes.labels(vnf_name=vnf_name, vnf_type=vnf_type)._value._value = tx_bytes
                
                # Store metrics for analysis
                self.vnf_metrics[vnf_name] = {
                    'cpu_percent': cpu_percent,
                    'memory_usage': memory_usage,
                    'rx_bytes': rx_bytes,
                    'tx_bytes': tx_bytes,
                    'timestamp': datetime.now()
                }
                
        except Exception as e:
            print(f"Error collecting VNF metrics: {e}")
    
    def collect_sfc_metrics(self):
        """Collect Service Function Chain metrics"""
        try:
            # Get OpenFlow statistics
            cmd = "ovs-ofctl dump-flows nfv-data -O OpenFlow13"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            for line in result.stdout.split('\n'):
                if 'reg0=' in line and 'n_packets=' in line:
                    # Parse flow statistics
                    parts = line.split(',')
                    path_id = None
                    packets = 0
                    
                    for part in parts:
                        if 'reg0=' in part:
                            path_id = part.split('=')[1].split(',')[0]
                        elif 'n_packets=' in part:
                            packets = int(part.split('=')[1])
                    
                    if path_id:
                        sfc_path_packets.labels(path_id=path_id)._value._value = packets
                        
        except Exception as e:
            print(f"Error collecting SFC metrics: {e}")
    
    def analyze_performance(self):
        """Analyze VNF performance and provide recommendations"""
        recommendations = []
        
        for vnf_name, metrics in self.vnf_metrics.items():
            cpu_percent = metrics['cpu_percent']
            memory_usage = metrics['memory_usage']
            
            # CPU analysis
            if cpu_percent > 80:
                recommendations.append({
                    'vnf': vnf_name,
                    'type': 'cpu_high',
                    'severity': 'critical',
                    'message': f'High CPU usage: {cpu_percent:.1f}%',
                    'recommendation': 'Consider scaling out or optimizing VNF'
                })
            elif cpu_percent < 10:
                recommendations.append({
                    'vnf': vnf_name,
                    'type': 'cpu_low',
                    'severity': 'info',
                    'message': f'Low CPU usage: {cpu_percent:.1f}%',
                    'recommendation': 'Consider scaling in to save resources'
                })
            
            # Memory analysis
            if memory_usage > 1024 * 1024 * 1024:  # 1GB
                recommendations.append({
                    'vnf': vnf_name,
                    'type': 'memory_high',
                    'severity': 'warning',
                    'message': f'High memory usage: {memory_usage / (1024**3):.1f}GB',
                    'recommendation': 'Monitor for memory leaks or increase allocation'
                })
        
        return recommendations
    
    def generate_report(self):
        """Generate performance report"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'vnf_count': len(self.vnf_metrics),
            'metrics': self.vnf_metrics,
            'recommendations': self.analyze_performance()
        }
        
        # Save report
        with open(f'/var/log/nfv-report-{int(time.time())}.json', 'w') as f:
            json.dump(report, f, indent=2, default=str)
        
        return report

def nfv_monitoring_loop():
    """Main monitoring loop"""
    monitor = NFVMonitor()
    
    while True:
        try:
            print(f"[{datetime.now()}] Collecting NFV metrics...")
            
            # Collect metrics
            monitor.collect_vnf_metrics()
            monitor.collect_sfc_metrics()
            
            # Generate report every 10 minutes
            if int(time.time()) % 600 == 0:
                report = monitor.generate_report()
                print(f"Generated performance report with {len(report['recommendations'])} recommendations")
            
            time.sleep(30)  # Collect metrics every 30 seconds
            
        except Exception as e:
            print(f"Error in monitoring loop: {e}")
            time.sleep(60)

def main():
    print("Starting NFV Metrics Collector...")
    
    # Start Prometheus metrics server
    start_http_server(8000)
    print("Prometheus metrics available at http://localhost:8000")
    
    # Start monitoring
    nfv_monitoring_loop()

if __name__ == '__main__':
    main()
EOF

# Create Grafana dashboard configuration
cat > grafana-nfv-dashboard.json << 'EOF'
{
  "dashboard": {
    "id": null,
    "title": "NFV Infrastructure Monitoring",
    "tags": ["nfv", "virtualization"],
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "VNF CPU Usage",
        "type": "graph",
        "targets": [
          {
            "expr": "vnf_cpu_usage_percent",
            "legendFormat": "{{vnf_name}} ({{vnf_type}})"
          }
        ],
        "yAxes": [
          {
            "min": 0,
            "max": 100,
            "unit": "percent"
          }
        ]
      },
      {
        "id": 2,
        "title": "VNF Memory Usage",
        "type": "graph",
        "targets": [
          {
            "expr": "vnf_memory_usage_bytes",
            "legendFormat": "{{vnf_name}} ({{vnf_type}})"
          }
        ],
        "yAxes": [
          {
            "min": 0,
            "unit": "bytes"
          }
        ]
      },
      {
        "id": 3,
        "title": "VNF Network Traffic",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(vnf_network_rx_bytes_total[5m])",
            "legendFormat": "RX {{vnf_name}}"
          },
          {
            "expr": "rate(vnf_network_tx_bytes_total[5m])",
            "legendFormat": "TX {{vnf_name}}"
          }
        ],
        "yAxes": [
          {
            "min": 0,
            "unit": "Bps"
          }
        ]
      },
      {
        "id": 4,
        "title": "Service Chain Packet Flow",
        "type": "stat",
        "targets": [
          {
            "expr": "sfc_path_packets_total",
            "legendFormat": "Path {{path_id}}"
          }
        ]
      },
      {
        "id": 5,
        "title": "VNF Instance Overview",
        "type": "table",
        "targets": [
          {
            "expr": "vnf_cpu_usage_percent",
            "format": "table"
          }
        ]
      }
    ],
    "time": {
      "from": "now-1h",
      "to": "now"
    },
    "refresh": "10s"
  }
}
EOF

# Create NFV optimization script
cat > nfv-optimizer.py << 'EOF'
#!/usr/bin/env python3

# NFV Performance Optimizer
import json
import subprocess
import time
from datetime import datetime

class NFVOptimizer:
    def __init__(self):
        self.optimization_history = []
        
    def optimize_vnf_placement(self):
        """Optimize VNF placement across physical resources"""
        print("Analyzing VNF placement...")
        
        # Get current VNF distribution
        cmd = "docker ps --format 'table {{.Names}}\t{{.Image}}\t{{.Status}}' --filter label=vnf.type"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        
        # Simple optimization: ensure even distribution
        # In production, this would use more sophisticated algorithms
        optimizations = []
        
        # Check for CPU affinity optimization
        vnf_containers = subprocess.run("docker ps -q --filter label=vnf.type", 
                                      shell=True, capture_output=True, text=True)
        
        for container_id in vnf_containers.stdout.strip().split('\n'):
            if container_id:
                # Set CPU affinity for better performance
                cmd = f"docker update --cpuset-cpus=0-1 {container_id}"
                subprocess.run(cmd, shell=True)
                
                optimizations.append({
                    'type': 'cpu_affinity',
                    'container': container_id,
                    'action': 'Set CPU affinity to cores 0-1'
                })
        
        return optimizations
    
    def optimize_network_flows(self):
        """Optimize OpenFlow rules for better performance"""
        print("Optimizing network flows...")
        
        optimizations = []
        
        # Get current flow statistics
        cmd = "ovs-ofctl dump-flows nfv-data"
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        
        # Analyze flow patterns and optimize
        flows = result.stdout.split('\n')
        high_traffic_flows = []
        
        for flow in flows:
            if 'n_packets=' in flow:
                # Extract packet count
                parts = flow.split(',')
                for part in parts:
                    if 'n_packets=' in part:
                        packets = int(part.split('=')[1])
                        if packets > 1000:  # High traffic threshold
                            high_traffic_flows.append(flow)
        
        # Optimize high-traffic flows with higher priority
        for i, flow in enumerate(high_traffic_flows[:5]):  # Top 5 flows
            if 'priority=' in flow:
                # Increase priority for high-traffic flows
                new_priority = 200 + i
                optimized_flow = flow.replace('priority=100', f'priority={new_priority}')
                
                optimizations.append({
                    'type': 'flow_priority',
                    'action': f'Increased priority to {new_priority}',
                    'flow': optimized_flow[:100] + '...'  # Truncate for display
                })
        
        return optimizations
    
    def optimize_resource_allocation(self):
        """Optimize resource allocation for VNFs"""
        print("Optimizing resource allocation...")
        
        optimizations = []
        
        # Get system resource usage
        import psutil
        
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        
        # Adjust VNF resources based on system load
        if cpu_percent > 80:
            # Scale down non-critical VNFs
            cmd = """docker ps --filter label=vnf.type --format '{{.Names}}'"""
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            vnf_names = result.stdout.strip().split('\n')
            for vnf_name in vnf_names[:2]:  # Limit first 2 VNFs
                if vnf_name:
                    # Reduce CPU allocation
                    cmd = f"docker update --cpus=1.0 {vnf_name}"
                    subprocess.run(cmd, shell=True)
                    
                    optimizations.append({
                        'type': 'resource_scaling',
                        'vnf': vnf_name,
                        'action': 'Reduced CPU allocation to 1.0'
                    })
        
        elif cpu_percent < 30:
            # Scale up VNFs for better performance
            cmd = """docker ps --filter label=vnf.type --format '{{.Names}}'"""
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            
            vnf_names = result.stdout.strip().split('\n')
            for vnf_name in vnf_names[:2]:
                if vnf_name:
                    # Increase CPU allocation
                    cmd = f"docker update --cpus=2.0 {vnf_name}"
                    subprocess.run(cmd, shell=True)
                    
                    optimizations.append({
                        'type': 'resource_scaling',
                        'vnf': vnf_name,
                        'action': 'Increased CPU allocation to 2.0'
                    })
        
        return optimizations
    
    def run_optimization_cycle(self):
        """Run complete optimization cycle"""
        print(f"[{datetime.now()}] Starting NFV optimization cycle...")
        
        all_optimizations = []
        
        # Run optimizations
        all_optimizations.extend(self.optimize_vnf_placement())
        all_optimizations.extend(self.optimize_network_flows())
        all_optimizations.extend(self.optimize_resource_allocation())
        
        # Record optimization results
        optimization_record = {
            'timestamp': datetime.now().isoformat(),
            'optimizations': all_optimizations,
            'count': len(all_optimizations)
        }
        
        self.optimization_history.append(optimization_record)
        
        # Save optimization log
        with open('/var/log/nfv-optimizations.json', 'w') as f:
            json.dump(self.optimization_history, f, indent=2)
        
        print(f"Applied {len(all_optimizations)} optimizations")
        
        return optimization_record

def main():
    optimizer = NFVOptimizer()
    
    print("Starting NFV Performance Optimizer...")
    
    while True:
        try:
            # Run optimization every 10 minutes
            optimization_record = optimizer.run_optimization_cycle()
            
            # Print summary
            print(f"Optimization Summary:")
            for opt in optimization_record['optimizations']:
                print(f"  - {opt['type']}: {opt['action']}")
            
            # Wait before next cycle
            time.sleep(600)  # 10 minutes
            
        except Exception as e:
            print(f"Error in optimization cycle: {e}")
            time.sleep(300)  # 5 minutes on error

if __name__ == '__main__':
    main()
EOF

# Install Python dependencies and start services
pip3 install prometheus-client psutil

# Enable and start monitoring services
rc-update add prometheus default
rc-update add grafana-server default

service prometheus start
service grafana-server start

chmod +x *.py

echo "NFV monitoring and optimization configured! 📊"

What this does: 📖 Sets up comprehensive monitoring with performance optimization and intelligent recommendations.

Example output:

NFV monitoring and optimization configured! 📊

What this means: Complete NFV monitoring stack is active with automated optimization! ✅

🎉 You’re All Set!

Congratulations! You’ve successfully configured Network Function Virtualization on Alpine Linux! 🚀

What You’ve Accomplished:

✅ NFV Foundation - Complete containerization and SDN infrastructure
✅ Virtual Network Functions - Firewall and load balancer VNFs
✅ Orchestration System - Automated VNF lifecycle management
✅ Service Function Chaining - Traffic steering and service composition
✅ Monitoring & Optimization - Performance analytics and intelligent tuning

Architecture Overview:

┌─────────────────────────────────────────────────────────┐
│                NFV Management Layer                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │Orchestrator │  │SFC Controller│  │Monitor/Opt │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                Virtual Network Functions                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │   Firewall  │→ │Load Balancer│→ │     App     │     │
│  │     VNF     │  │     VNF     │  │   Servers   │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│                SDN Infrastructure                      │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │   OVS Data  │  │   OVS Mgmt  │  │ OVS Control │     │
│  │   Bridge    │  │   Bridge    │  │   Bridge    │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘

Key Commands:

# Start NFV infrastructure
/opt/sfc-controller/deploy-sfc.sh

# Monitor VNFs
docker ps --filter label=vnf.type

# Check service chains
ovs-ofctl dump-flows nfv-data

# View metrics
curl http://localhost:8000/metrics

# Orchestrator management
cd /opt/nfv-orchestrator && python3 nfv-orchestrator.py

Next Steps:

• 🔧 Custom VNFs - Develop application-specific network functions
• 📈 Performance Tuning - Optimize for your traffic patterns
• 🔄 Automation - Integrate with CI/CD and infrastructure as code
• 🌐 Multi-Site - Extend to distributed NFV infrastructure
• 🛡️ Security - Implement advanced security policies and compliance

Your NFV infrastructure is now operational with intelligent orchestration and optimization! 😊🌐