A production-ready RPKI (Resource Public Key Infrastructure) visualization and validation backend that integrates with Routinator for real-time VRP (Validated ROA Payload) data processing and monitoring.

RPKI-viz is a Docker-based microservices architecture consisting of two core components:

1. Routinator - Official NLnet Labs RPKI validator daemon
2. RPKI Backend - Custom Python application for processing and API exposure

graph TB
    subgraph External["External Systems"]
        RIR["RIRs (ARIN, RIPE, etc.)"]
        CLIENT["Client Apps"]
        PROM["Prometheus"]
    end

    subgraph Docker["Docker Stack"]
        ROUT["Routinator Container<br/>(Ports 8323, 3323)"]
        BACKEND["Backend Container<br/>(Port 8080)"]
        
        VOL1[("routinator-cache")]
        VOL2[("backend-state")]
    end

    subgraph BackendModules["Backend Components"]
        VRP["VRP Loader<br/>(Fetch & Validate)"]
        DIFF["Diff Engine<br/>(Track Changes)"]
        METR["Metrics"]
        API["API Server<br/>(Flask)"]
    end

    %% Data Flow
    RIR -->|Sync RPKI Data| ROUT
    ROUT -->|JSON VRPs| VRP
    VRP -->|Process| DIFF
    DIFF -->|Store| VOL2
    
    CLIENT -->|REST API| API
    PROM -->|Scrape| METR
    
    API -->|Query| DIFF
    API -->|Record| METR
    
    %% Internal
    ROUT -.->|Cache| VOL1
    BACKEND --> BackendModules

    classDef external fill:#e1f5ff,stroke:#01579b
    classDef container fill:#fff3e0,stroke:#e65100
    classDef module fill:#f3e5f5,stroke:#4a148c
    classDef storage fill:#e8f5e9,stroke:#1b5e20
    
    class RIR,CLIENT,PROM external
    class ROUT,BACKEND container
    class BackendModules,VRP,DIFF,METR,API module
    class VOL1,VOL2 storage

• Real-time VRP Processing: Polls Routinator every 10 minutes for updated RPKI data
• Change Detection: Computes diffs between VRP snapshots with monotonic serial numbers
• RESTful API: Comprehensive HTTP endpoints for VRP data access and validation
• Data Validation: Strict schema validation using Pydantic models
• Observability: Prometheus metrics for monitoring and alerting
• Persistence: Disk-based state storage with automatic recovery
• Containerized: Docker-based deployment with health checks

# Health check
curl http://localhost:8080/health

# Get current state
curl http://localhost:8080/api/v1/state

# Get all VRPs
curl http://localhost:8080/api/v1/vrps

# Filter VRPs by ASN
curl "http://localhost:8080/api/v1/vrps?asn=AS12345"

# Validate a route
curl -X POST http://localhost:8080/api/v1/validate \
  -H "Content-Type: application/json" \
  -d '{"asn": "AS12345", "prefix": "192.0.2.0/24"}'

{
  "asn": "AS65000",
  "prefix": "192.0.2.0/24",
  "maxLength": 24,
  "ta": "arin"
}

{
  "serial": 42,
  "vrp_count": 786005,
  "hash": "abc123def456...",
  "last_update": "2023-12-19T01:23:45.678901",
  "vrps": [...]
}

• Docker Engine 20.10+
• Docker Compose 2.0+
• 2GB RAM minimum
• 10GB disk space for RPKI cache

1. Clone the repository

   git clone git@github.com:Arjun4522/RPKI-viz.git
   cd RPKI-viz

2. Start the services

   docker-compose up -d

3. Verify deployment

   docker-compose ps
   watch -n 10 'curl -s http://localhost:8323/json 2>&1 | head -5'   

Once Initial Validation complete, restart backend container

Environment variables for the backend service:

The system uses Docker volumes for persistent storage:

• routinator-cache: RPKI repository cache (~5-10GB)
• backend-state: Application state and diffs (~1-2GB)

• Routinator: File existence check in cache directory
• Backend: HTTP health endpoint (/health)

RPKI-viz-3/
├── backend/
│   ├── main.py              # Main application controller
│   ├── api_server.py        # Flask API server
│   ├── vrp_loader.py        # Routinator integration
│   ├── diff_engine.py       # Change detection engine
│   ├── metrics.py           # Prometheus metrics
│   ├── requirements.txt     # Python dependencies
│   └── Dockerfile          # Backend container definition
├── docker-compose.yml       # Multi-container deployment
└── README.md               # This file

1. Build the backend image

   cd backend
   docker build -t rpki-backend .

2. Update docker-compose.yml

   rpki-backend:
     image: rpki-backend:latest
     # instead of build: ./backend

# Test API endpoints
curl http://localhost:8080/health
curl http://localhost:8080/metrics

# Test data processing
curl http://localhost:8080/api/v1/state
curl http://localhost:8080/api/v1/vrps?asn=AS15169

# Test route validation
curl -X POST http://localhost:8080/api/v1/validate \
  -H "Content-Type: application/json" \
  -d '{"asn": "AS15169", "prefix": "8.8.8.0/24"}'

• VRP Processing: ~786,000 VRPs processed in ~60 seconds
• Memory Usage: Backend ~256MB, Routinator ~512MB
• Storage: ~1GB for state, ~5GB for RPKI cache
• API Response Time: <100ms for most endpoints

1. Routinator not ready

   # Check Routinator logs
   docker logs routinator
   
   # Wait for initial sync (5-10 minutes)

2. Backend unhealthy

   # Healthcheck uses wget which may not be available
   # The API is still functional - check /health endpoint
   curl http://localhost:8080/health

3. VRP fetch failures

   # Check Routinator accessibility
   curl http://localhost:8323/json | head -n 5

# View backend logs
docker logs rpki-backend

# View Routinator logs
docker logs routinator

# Follow logs in real-time
docker logs -f rpki-backend

• Non-root user execution in containers
• Read-only access to RPKI data
• No authentication on API endpoints (intended for internal use)
• Input validation on all API parameters
• No persistent secrets or credentials

• Horizontal Scaling: Multiple backend instances can read from shared state
• Load Balancing: API endpoints are stateless and cache-friendly
• Storage: State directory can be mounted from network storage
• Monitoring: All metrics exposed for Prometheus scraping

1. Fork the repository
2. Create a feature branch
3. Make changes with tests
4. Submit a pull request

[Add appropriate license information]

• RPKI Overview
• Routinator Documentation
• RFC 6480 - RPKI Architecture
• RFC 6811 - BGP Prefix Origin Validation

For issues and questions:

1. Check the troubleshooting section
2. Review container logs
3. Examine API responses
4. Open a GitHub issue