Akash Network：去中心化云如何挑战AWS影视渲染垄断

pragma solidity ^0.8.20;

contract RenderingEscrow {
    address public payer;
    address public provider;
    uint256 public budget;
    uint256 public deadline;
    bool public completed;
    
    modifier onlyPayer() {
        require(msg.sender == payer, "Unauthorized");
        _;
    }
    
    modifier onlyProvider() {
        require(msg.sender == provider, "Unauthorized");
        _;
    }
    
    constructor(address _provider, uint256 _budget, uint256 _duration) payable {
        require(msg.value >= _budget, "Insufficient funds");
        payer = msg.sender;
        provider = _provider;
        budget = _budget;
        deadline = block.timestamp + _duration;
        completed = false;
    }
    
    function releaseFunds(bytes32 jobHash) external onlyPayer {
        require(!completed, "Already completed");
        completed = true;
        payable(provider).transfer(budget);
    }
    
    function dispute(bytes32 jobHash, bytes memory evidence) external onlyProvider {
        require(block.timestamp > deadline && !completed, "Invalid dispute");
        payable(provider).transfer(budget * 50 / 100);
        payable(payer).transfer(budget * 50 / 100);
        completed = true;
    }
    
    function refund() external onlyPayer {
        require(block.timestamp > deadline + 30 days && !completed, "Too early");
        completed = true;
        payable(payer).transfer(budget);
    }
}

import subprocess
import json
import requests
import time
import hashlib

AKASH_API = "https://rest.akash.network/v1"
BID_PRICE = "8000000"
DENOM = "uakt"

def generate_manifest(image, gpu_count, memory_mb, cpu_units):
    return {
        "version": "2.0",
        "services": {
            "render-worker": {
                "image": image,
                "command": ["/bin/bash", "-c"],
                "args": ["/opt/worker/start.sh"],
                "expose": [
                    {
                        "port": 8080,
                        "as": 80,
                        "to": [{"global": True}]
                    }
                ],
                "params": {
                    "storage": {
                        "data": {
                            "mount": "/mnt/render",
                            "readOnly": False
                        }
                    }
                },
                "resources": {
                    "cpu": {"units": str(cpu_units)},
                    "memory": {"size": f"{memory_mb}Mi"},
                    "storage": [{"name": "data", "size": "500Gi"}],
                    "gpu": {
                        "units": str(gpu_count),
                        "attributes": {
                            "vendor": {
                                "nvidia": {"model": "a100"}
                            }
                        }
                    }
                }
            }
        },
        "profiles": {
            "placement": {
                "global": {
                    "pricing": {
                        "render-worker": {
                            "denom": DENOM,
                            "amount": BID_PRICE
                        }
                    }
                }
            }
        },
        "deployment": {
            "render-worker": {
                "global": {"profile": "global", "count": 1}
            }
        }
    }

def submit_deployment(cert_path, key_path, manifest):
    manifest_hash = hashlib.sha256(json.dumps(manifest).encode()).hexdigest()
    deployment_url = f"{AKASH_API}/deployments"
    headers = {"Content-Type": "application/json"}
    response = requests.post(
        deployment_url,
        json={"manifest": manifest, "manifest_hash": manifest_hash},
        headers=headers,
        cert=(cert_path, key_path)
    )
    return response.json()

def monitor_leases(deployment_id, poll_interval=30):
    while True:
        url = f"{AKASH_API}/leases?deployment_id={deployment_id}"
        resp = requests.get(url)
        leases = resp.json().get("leases", [])
        active = sum(1 for l in leases if l["state"] == "active")
        total = len(leases)
        print(f"[{time.strftime('%H:%M:%S')}] Active: {active}/{total}")
        if active == total and total > 0:
            return leases
        time.sleep(poll_interval)

def collect_render_results(leases, output_bucket):
    results = []
    for lease in leases:
        host = lease["provider_host"]
        port = lease["public_port"]
        result_url = f"http://{host}:{port}/api/v1/results"
        resp = requests.get(result_url)
        frames = resp.json().get("frames", [])
        for frame in frames:
            results.append(frame["url"])
            requests.get(frame["url"])
    return results

if __name__ == "__main__":
    manifest = generate_manifest(
        image="bcustudio/render-worker:v3.1",
        gpu_count=2,
        memory_mb=65536,
        cpu_units=16
    )
    result = submit_deployment("client.crt", "client.key", manifest)
    deployment_id = result["deployment_id"]
    print(f"Submitted: {deployment_id}")
    leases = monitor_leases(deployment_id)
    outputs = collect_render_results(leases, "s3://bcu-render-output")
    print(f"Collected {len(outputs)} rendered frames")

const axios = require("axios");

const AKASH_RPC = "https://rpc.akash.network";
const AWS_PRICING = {
  "p4d.24xlarge": { hourly: 32.77, gpu: "a100", gpuCount: 8 },
  "p5.48xlarge": { hourly: 40.96, gpu: "h100", gpuCount: 8 },
  "g5.16xlarge": { hourly: 4.096, gpu: "a10g", gpuCount: 1 }
};

async function fetchAkashBids(gpuModel, gpuCount) {
  const query = `/akash/market/v1beta4/bids?filters.gpu_model=${gpuModel}&filters.gpu_count=${gpuCount}&state=open`;
  const response = await axios.get(`${AKASH_RPC}${query}`);
  return response.data.bids.map(b => ({
    provider: b.provider,
    price: parseFloat(b.price.amount) / 1e6,
    denom: b.price.denom,
    attributes: b.resources.attributes
  }));
}

async function calculateRenderCost(totalFrames, timePerFrameSec, gpuModel, gpuCount) {
  const bids = await fetchAkashBids(gpuModel, gpuCount);
  bids.sort((a, b) => a.price - b.price);
  const medianBid = bids[Math.floor(bids.length / 2)];
  const totalGpuHours = (totalFrames * timePerFrameSec) / 3600;
  const akashCost = totalGpuHours * medianBid.price;
  
  const awsInstance = Object.values(AWS_PRICING).find(
    p => p.gpu === gpuModel && p.gpuCount >= gpuCount
  );
  const awsCost = awsInstance ? totalGpuHours * (awsInstance.hourly / awsInstance.gpuCount) : null;
  
  return {
    scenario: { totalFrames, timePerFrameSec, gpuModel, gpuCount },
    akash: { medianBid: medianBid.price, totalCost: akashCost, totalGpuHours },
    aws: { instanceHourly: awsInstance?.hourly, totalCost: awsCost, totalGpuHours },
    savings: awsCost ? ((awsCost - akashCost) / awsCost * 100).toFixed(1) + "%" : "N/A"
  };
}

async function generateReport() {
  const scenarios = [
    { totalFrames: 9000, timePerFrameSec: 60, gpuModel: "a100", gpuCount: 1 },
    { totalFrames: 4500, timePerFrameSec: 120, gpuModel: "a100", gpuCount: 2 },
    { totalFrames: 18000, timePerFrameSec: 30, gpuModel: "a10g", gpuCount: 1 }
  ];
  
  const results = await Promise.all(scenarios.map(s => calculateRenderCost(...Object.values(s))));
  
  results.forEach((r, i) => {
    console.log(`\nScenario ${i + 1}: ${r.scenario.totalFrames} frames @ ${r.scenario.timePerFrameSec}s`);
    console.log(`  GPU: ${r.scenario.gpuModel} x${r.scenario.gpuCount}`);
    console.log(`  Akash median bid: $${r.akash.medianBid}/hr`);
    console.log(`  Akash total: $${r.akash.totalCost.toFixed(2)}`);
    console.log(`  AWS total: $${r.aws.totalCost?.toFixed(2) || "N/A"}`);
    console.log(`  Savings: ${r.savings}`);
  });
}

generateReport().catch(console.error);