♻️ Chapter 4: Implementation Guide

4.1 Pre-Implementation Planning

Successful WIA-ENE-004 implementation begins with thorough planning. This section guides you through the essential preparation steps before deploying the standard.

Requirements Assessment

Stakeholder Identification

• Executive Sponsors: Provide budget, strategic direction, and organizational support
• Technical Teams: Implement and maintain the system (DevOps, engineers, architects)
• Operations Teams: Day-to-day system monitoring and management
• Compliance/Legal: Ensure regulatory adherence and risk management
• End Users: Dashboard users, analysts, external stakeholders

4.2 Environment Setup

Setting up the development, staging, and production environments is the foundation of your implementation.

Development Environment Setup

# Install WIA-ENE-004 CLI tools
curl -fsSL https://get.wia.org/ene-004/install.sh | bash

# Verify installation
wia-ene --version
# Output: WIA-ENE-004 CLI v1.0.0

# Initialize new project
wia-ene init my-renewable-energy-project
cd my-renewable-energy-project

# Project structure created:
# my-renewable-energy-project/
# ├── config/
# │   ├── development.yaml
# │   ├── staging.yaml
# │   └── production.yaml
# ├── sources/
# │   └── example-solar.yaml
# ├── schemas/
# │   └── custom-extensions.json
# └── scripts/
#     ├── deploy.sh
#     └── test.sh

Configuration File Example

# config/development.yaml
environment: development
standard: WIA-ENE-004
version: 1.0

api:
  endpoint: http://localhost:8080
  authentication:
    method: oauth2
    clientId: dev-client
    clientSecret: ${DEV_CLIENT_SECRET}

database:
  timeseries:
    type: influxdb
    url: http://localhost:8086
    database: renewable_energy_dev
    retention: 30d

  metadata:
    type: postgresql
    host: localhost
    port: 5432
    database: wia_ene_dev
    user: wia_dev
    password: ${DB_PASSWORD}

mqtt:
  broker: mqtt://localhost:1883
  topics:
    production: wia-ene/dev/sources/+/production
    status: wia-ene/dev/sources/+/status
    alerts: wia-ene/dev/alerts/#

logging:
  level: DEBUG
  format: json
  output: stdout

Docker Compose for Local Development

version: '3.8'

services:
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=password
      - DOCKER_INFLUXDB_INIT_ORG=wia
      - DOCKER_INFLUXDB_INIT_BUCKET=renewable_energy
    volumes:
      - influxdb-data:/var/lib/influxdb2

  postgres:
    image: timescale/timescaledb:latest-pg15
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_DB=wia_ene_dev
      - POSTGRES_USER=wia_dev
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres-data:/var/lib/postgresql/data

  mosquitto:
    image: eclipse-mosquitto:2.0
    ports:
      - "1883:1883"
      - "9001:9001"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - mosquitto-data:/mosquitto/data

  wia-ene-api:
    image: wia/ene-004-api:latest
    ports:
      - "8080:8080"
    environment:
      - CONFIG_FILE=/config/development.yaml
    depends_on:
      - influxdb
      - postgres
      - mosquitto
    volumes:
      - ./config:/config

volumes:
  influxdb-data:
  postgres-data:
  mosquitto-data:

4.3 Energy Source Registration

Register your renewable energy sources in the WIA-ENE-004 system with proper metadata and configuration.

Source Definition Example

# sources/solar-pv-rooftop-001.yaml
sourceId: SOLAR-PV-001
sourceType: SOLAR-PV
name: "Headquarters Rooftop Solar Array"

metadata:
  installDate: "2024-03-15"
  manufacturer: "SunPower Corporation"
  model: "SPR-MAX3-400"
  serialNumber: "SP400-2024-001234"

location:
  latitude: 37.7749
  longitude: -122.4194
  elevation: 52
  address: "123 Green Energy Blvd, San Francisco, CA 94103"
  timezone: "America/Los_Angeles"

capacity:
  rated: 150
  unit: kW
  dcRating: 165
  acRating: 150
  panels: 375
  panelWattage: 400

inverter:
  manufacturer: "SolarEdge"
  model: "SE150K-US"
  efficiency: 98.3
  warranty: "12 years"

monitoring:
  enabled: true
  interval: 60
  metrics:
    - production
    - voltage
    - current
    - temperature
    - irradiance

grid:
  connection: "main"
  voltageLevel: 480
  frequency: 60
  netMetering: true

certifications:
  - "UL 1703"
  - "IEC 61730"
  - "WIA-ENE-004-BASIC"

contacts:
  - role: "Site Manager"
    name: "Jane Smith"
    email: "jane.smith@example.com"
    phone: "+1-555-0123"

Registration via CLI

# Register energy source
wia-ene source register sources/solar-pv-rooftop-001.yaml

# Output:
# ✓ Source registered successfully
# Source ID: SOLAR-PV-001
# Type: SOLAR-PV
# Capacity: 150 kW
# Status: PENDING_ACTIVATION

# List all sources
wia-ene source list

# Get source details
wia-ene source get SOLAR-PV-001 --format json

# Update source configuration
wia-ene source update SOLAR-PV-001 --file updated-config.yaml

# Activate source for monitoring
wia-ene source activate SOLAR-PV-001

4.4 Data Integration

Integrate your energy sources with the WIA-ENE-004 platform to begin collecting and analyzing production data.

Integration Methods

MQTT Integration Example

// TypeScript: Publish production data via MQTT
import mqtt from 'mqtt'

const client = mqtt.connect('mqtt://localhost:1883', {
  username: 'solar-pv-001',
  password: process.env.MQTT_PASSWORD
})

client.on('connect', () => {
  console.log('Connected to MQTT broker')

  // Publish production data every minute
  setInterval(() => {
    const data = {
      timestamp: new Date().toISOString(),
      sourceId: 'SOLAR-PV-001',
      production: {
        instantaneous: {
          value: getCurrentPower(),
          unit: 'kW'
        },
        cumulative: {
          today: getTodayProduction(),
          unit: 'kWh'
        }
      },
      efficiency: calculateEfficiency(),
      environmentalConditions: {
        solarIrradiance: getIrradiance(),
        ambientTemperature: getTemperature(),
        panelTemperature: getPanelTemp()
      }
    }

    client.publish(
      'wia-ene/sources/SOLAR-PV-001/production',
      JSON.stringify(data),
      { qos: 1 }
    )
  }, 60000)
})

function getCurrentPower() {
  // Read from inverter API or sensor
  return 142.5 // kW
}

function getTodayProduction() {
  // Calculate cumulative production since midnight
  return 856.3 // kWh
}

function calculateEfficiency() {
  const actual = getCurrentPower()
  const rated = 150 // kW
  const irradiance = getIrradiance()
  const standardIrradiance = 1000 // W/m²

  const expected = rated * (irradiance / standardIrradiance)
  return (actual / expected) * 100
}

REST API Integration Example

// Python: Submit production data via REST API
import requests
import json
from datetime import datetime

API_ENDPOINT = "https://api.wia.org/v1/sources/SOLAR-PV-001/production"
API_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

def submit_production_data(power, energy, efficiency):
    data = {
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "production": {
            "instantaneous": {
                "value": power,
                "unit": "kW"
            },
            "cumulative": {
                "today": energy,
                "unit": "kWh"
            }
        },
        "efficiency": {
            "current": efficiency,
            "unit": "percent"
        }
    }

    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Content-Type": "application/json"
    }

    response = requests.post(
        API_ENDPOINT,
        headers=headers,
        json=data
    )

    if response.status_code == 201:
        print("Data submitted successfully")
        return response.json()
    else:
        print(f"Error: {response.status_code}")
        print(response.text)
        return None

# Submit data every 5 minutes
import time
while True:
    power = read_inverter_power()
    energy = read_daily_energy()
    efficiency = calculate_efficiency()

    submit_production_data(power, energy, efficiency)
    time.sleep(300)  # 5 minutes

4.5 Testing and Validation

Comprehensive testing ensures your WIA-ENE-004 implementation meets all requirements and performs reliably.

Test Pyramid

Compliance Testing

# Run WIA-ENE-004 compliance test suite
wia-ene test compliance --source SOLAR-PV-001

# Test categories:
# ✓ Data Format Validation
#   - Schema compliance: PASS
#   - Required fields present: PASS
#   - Data types correct: PASS
#
# ✓ API Endpoint Tests
#   - GET /sources/{id}: PASS (142ms)
#   - GET /sources/{id}/production: PASS (98ms)
#   - GET /sources/{id}/status: PASS (76ms)
#
# ✓ Security Tests
#   - TLS 1.3 enforced: PASS
#   - Authentication required: PASS
#   - Authorization working: PASS
#
# ✓ Performance Tests
#   - API latency p95 < 200ms: PASS (154ms)
#   - Data ingestion rate: PASS (2.3K points/sec)
#   - Query response time: PASS (89ms)
#
# ✓ Interoperability Tests
#   - MQTT connectivity: PASS
#   - JSON schema valid: PASS
#   - Timestamp format: PASS (ISO 8601)
#
# Overall: COMPLIANT ✓
# Certification level: WIA-ENE-004-BASIC
# Valid until: 2026-12-25

4.6 Deployment Process

Deploy your WIA-ENE-004 implementation following these production-ready procedures.

Deployment Checklist

• ✓ All tests passing (unit, integration, E2E, compliance)
• ✓ Security scan completed (no critical vulnerabilities)
• ✓ Performance benchmarks met
• ✓ Database migrations tested and ready
• ✓ Monitoring and alerting configured
• ✓ Backup and recovery procedures documented
• ✓ Rollback plan prepared
• ✓ Stakeholders notified of deployment window
• ✓ Documentation updated

Blue-Green Deployment Example

# Deploy to green environment (new version)
kubectl apply -f k8s/deployment-green.yaml

# Wait for green environment to be healthy
kubectl rollout status deployment/wia-ene-api-green

# Run smoke tests on green environment
./scripts/smoke-test.sh green

# Switch traffic from blue to green
kubectl patch service wia-ene-api -p '{"spec":{"selector":{"version":"green"}}}'

# Monitor for issues (keep blue running for rollback)
# After 1 hour with no issues, scale down blue
kubectl scale deployment/wia-ene-api-blue --replicas=0

Production Deployment Script

#!/bin/bash
# deploy-production.sh

set -e

echo "Starting WIA-ENE-004 production deployment..."

# 1. Backup current database
echo "Creating database backup..."
./scripts/backup-db.sh

# 2. Deploy infrastructure changes
echo "Deploying infrastructure..."
terraform apply -auto-approve

# 3. Run database migrations
echo "Running database migrations..."
./scripts/migrate.sh production

# 4. Deploy application
echo "Deploying application..."
kubectl apply -f k8s/production/

# 5. Wait for rollout
echo "Waiting for rollout to complete..."
kubectl rollout status deployment/wia-ene-api -n production

# 6. Run smoke tests
echo "Running smoke tests..."
./scripts/smoke-test.sh production

# 7. Verify monitoring
echo "Verifying monitoring and alerts..."
./scripts/verify-monitoring.sh

echo "Deployment completed successfully!"

4.7 Monitoring and Observability

Set up comprehensive monitoring to ensure your WIA-ENE-004 system operates reliably and efficiently.

Key Metrics to Monitor

Prometheus Configuration

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'wia-ene-api'
    static_configs:
      - targets: ['wia-ene-api:8080']
    metrics_path: '/metrics'

  - job_name: 'energy-sources'
    static_configs:
      - targets: ['solar-gateway:9091', 'wind-gateway:9091']

rule_files:
  - 'alerts.yml'

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

Alert Rules

# alerts.yml
groups:
  - name: wia-ene-004
    interval: 30s
    rules:
      - alert: HighAPILatency
        expr: histogram_quantile(0.95, rate(api_request_duration_seconds_bucket[5m])) > 0.2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High API latency detected"
          description: "95th percentile latency is {{ $value }}s"

      - alert: LowEnergyProduction
        expr: energy_production_kw < (predicted_production_kw * 0.7)
        for: 15m
        labels:
          severity: medium
        annotations:
          summary: "Energy production below expected"
          description: "{{ $labels.source_id }} producing {{ $value }}kW, expected {{ $labels.predicted }}kW"

      - alert: DataIngestionFailure
        expr: rate(data_ingestion_errors_total[5m]) > 0.01
        for: 2m
        labels:
          severity: high
        annotations:
          summary: "Data ingestion errors detected"
          description: "Error rate: {{ $value }} errors/sec"

4.8 Troubleshooting Common Issues

Resolve common implementation challenges quickly with these troubleshooting guides.

4.9 Performance Optimization

Optimize your WIA-ENE-004 implementation for maximum efficiency and minimal resource usage.

Optimization Strategies

• Database Indexing: Create indexes on frequently queried fields (sourceId, timestamp)
• Caching: Use Redis for frequently accessed data (source metadata, recent production)
• Data Aggregation: Pre-compute hourly/daily aggregates to reduce query load
• Batch Processing: Group database writes to reduce transaction overhead
• Connection Pooling: Reuse database connections to minimize overhead
• CDN for Static Assets: Serve web dashboards via CDN for global performance
• Compression: Enable gzip compression for API responses

// Caching example with Redis
import Redis from 'ioredis'

const redis = new Redis({
  host: 'localhost',
  port: 6379
})

async function getSourceProduction(sourceId: string) {
  // Try cache first
  const cached = await redis.get(`production:${sourceId}`)
  if (cached) {
    return JSON.parse(cached)
  }

  // Cache miss - fetch from database
  const data = await database.query(
    'SELECT * FROM production WHERE source_id = ? ORDER BY timestamp DESC LIMIT 1',
    [sourceId]
  )

  // Cache for 60 seconds
  await redis.setex(
    `production:${sourceId}`,
    60,
    JSON.stringify(data)
  )

  return data
}

4.10 Implementation Checklist

Use this comprehensive checklist to ensure you've completed all essential implementation tasks.