Benchmarks: Cloudflare R2 vs. AWS S3 for Static Website Hosting

import boto3
import time
import statistics
from botocore.exceptions import ClientError, EndpointConnectionError
import argparse
import json

# Benchmark configuration - matches our stated methodology
ACCOUNT_ID = "your-r2-account-id"
R2_ACCESS_KEY = "your-r2-access-key"
R2_SECRET_KEY = "your-r2-secret-key"
S3_ACCESS_KEY = "your-aws-access-key"
S3_SECRET_KEY = "your-aws-secret-key"
R2_ENDPOINT = f"https://{ACCOUNT_ID}.r2.cloudflarestorage.com"
S3_REGION = "us-east-1"
TEST_BUCKET_R2 = "static-hosting-bench-r2"
TEST_BUCKET_S3 = "static-hosting-bench-s3"
TEST_OBJECT_KEY = "10kb-asset.html"  # Pre-uploaded 10KB HTML file
REQUEST_COUNT = 1000  # Per test run, 3 runs averaged per benchmark spec

def init_clients():
    """Initialize S3-compatible clients for R2 and S3 with error handling"""
    try:
        r2_client = boto3.client(
            service_name="s3",
            endpoint_url=R2_ENDPOINT,
            aws_access_key_id=R2_ACCESS_KEY,
            aws_secret_access_key=R2_SECRET_KEY,
            region_name="auto"  # R2 uses auto region for S3 compat
        )
        s3_client = boto3.client(
            service_name="s3",
            region_name=S3_REGION,
            aws_access_key_id=S3_ACCESS_KEY,
            aws_secret_access_key=S3_SECRET_KEY
        )
        # Verify bucket access
        r2_client.head_bucket(Bucket=TEST_BUCKET_R2)
        s3_client.head_bucket(Bucket=TEST_BUCKET_S3)
        return r2_client, s3_client
    except EndpointConnectionError as e:
        raise RuntimeError(f"Failed to connect to storage endpoint: {str(e)}")
    except ClientError as e:
        if e.response["Error"]["Code"] == "404":
            raise RuntimeError("Test bucket not found. Create buckets and upload test asset first.")
        raise RuntimeError(f"AWS/R2 client error: {str(e)}")

def run_latency_benchmark(client, bucket, key, request_count):
    """Run latency benchmark for a single client, return list of latencies in ms"""
    latencies = []
    for _ in range(request_count):
        try:
            start = time.perf_counter()
            # Use get_object to simulate static asset fetch, same as browser request
            response = client.get_object(Bucket=bucket, Key=key)
            # Read body to ensure full response is received
            response["Body"].read()
            end = time.perf_counter()
            latencies.append((end - start) * 1000)  # Convert to ms
        except ClientError as e:
            print(f"Request failed: {str(e)}")
            continue
    if not latencies:
        raise RuntimeError("No successful requests completed")
    return latencies

def calculate_stats(latencies):
    """Calculate p50, p95, p99, min, max latency"""
    sorted_lat = sorted(latencies)
    return {
        "p50": round(statistics.median(sorted_lat[:int(len(sorted_lat)*0.5)]), 2),
        "p95": round(sorted_lat[int(len(sorted_lat)*0.95)], 2),
        "p99": round(sorted_lat[int(len(sorted_lat)*0.99)], 2),
        "min": round(min(sorted_lat), 2),
        "max": round(max(sorted_lat), 2),
        "avg": round(statistics.mean(latencies), 2)
    }

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Benchmark R2 vs S3 static asset latency")
    parser.add_argument("--asset-size", choices=["10kb", "100kb", "1mb"], default="10kb")
    args = parser.parse_args()

    print(f"Starting benchmark for {args.asset_size} assets, {REQUEST_COUNT} requests per run")
    r2_client, s3_client = init_clients()

    # Run 3 test iterations, average results
    r2_results = []
    s3_results = []
    for i in range(3):
        print(f"Test iteration {i+1}/3")
        r2_lat = run_latency_benchmark(r2_client, TEST_BUCKET_R2, f"{args.asset_size}-asset.html", REQUEST_COUNT)
        s3_lat = run_latency_benchmark(s3_client, TEST_BUCKET_S3, f"{args.asset_size}-asset.html", REQUEST_COUNT)
        r2_results.append(calculate_stats(r2_lat))
        s3_results.append(calculate_stats(s3_lat))

    # Average across iterations
    avg_r2 = {
        k: round(statistics.mean([r[k] for r in r2_results]), 2) for k in r2_results[0]
    }
    avg_s3 = {
        k: round(statistics.mean([r[k] for r in s3_results]), 2) for k in s3_results[0]
    }

    print("\n=== Benchmark Results ===")
    print(f"Cloudflare R2 ({args.asset_size}): {json.dumps(avg_r2, indent=2)}")
    print(f"AWS S3 Standard ({args.asset_size}): {json.dumps(avg_s3, indent=2)}")
    print(f"R2 p99 improvement: {avg_s3['p99'] - avg_r2['p99']}ms ({round((avg_s3['p99'] - avg_r2['p99'])/avg_s3['p99']*100, 1)}% lower)")

# Terraform configuration to set up static website hosting on R2 and S3
# Requires Terraform 1.8+, cloudflare provider 4.36+, aws provider 5.50+

terraform {
  required_version = ">= 1.8.0"
  required_providers {
    cloudflare = {
      source  = "cloudflare/cloudflare"
      version = "~> 4.36.0"
    }
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.50.0"
    }
  }
}

# Cloudflare R2 Configuration
provider "cloudflare" {
  api_token = var.cloudflare_api_token
}

resource "cloudflare_r2_bucket" "static_site_r2" {
  account_id = var.cloudflare_account_id
  name       = "benchmark-static-site-r2"
  location   = "auto"  # R2 auto-selects optimal region
}

# Enable static website hosting on R2 (native feature, no extra services)
resource "cloudflare_r2_bucket_website_configuration" "r2_website" {
  account_id = var.cloudflare_account_id
  bucket     = cloudflare_r2_bucket.static_site_r2.name

  index_document {
    suffix = "index.html"
  }

  error_document {
    key = "404.html"
  }
}

# Upload sample static assets to R2
resource "cloudflare_r2_object" "r2_index" {
  account_id = var.cloudflare_account_id
  bucket     = cloudflare_r2_bucket.static_site_r2.name
  key        = "index.html"
  content    = file("${path.module}/static/index.html")
  content_type = "text/html"
}

resource "cloudflare_r2_object" "r2_404" {
  account_id = var.cloudflare_account_id
  bucket     = cloudflare_r2_bucket.static_site_r2.name
  key        = "404.html"
  content    = file("${path.module}/static/404.html")
  content_type = "text/html"
}

# AWS S3 Configuration
provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "static_site_s3" {
  bucket = "benchmark-static-site-s3-${random_string.suffix.result}"
  tags = {
    Environment = "benchmark"
    Purpose     = "static-hosting-comparison"
  }
}

resource "random_string" "suffix" {
  length  = 8
  special = false
  upper   = false
}

# Enable static website hosting on S3
resource "aws_s3_bucket_website_configuration" "s3_website" {
  bucket = aws_s3_bucket.static_site_s3.id

  index_document {
    suffix = "index.html"
  }

  error_document {
    key = "404.html"
  }
}

# Disable block public access for S3 static hosting (required for direct access)
resource "aws_s3_bucket_public_access_block" "s3_public_access" {
  bucket = aws_s3_bucket.static_site_s3.id

  block_public_acls       = false
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}

# Bucket policy to allow public read for static assets
resource "aws_s3_bucket_policy" "s3_website_policy" {
  bucket = aws_s3_bucket.static_site_s3.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Sid       = "PublicReadGetObject"
        Effect    = "Allow"
        Principal = "*"
        Action    = "s3:GetObject"
        Resource  = "${aws_s3_bucket.static_site_s3.arn}/*"
      }
    ]
  })
  depends_on = [aws_s3_bucket_public_access_block.s3_public_access]
}

# Upload sample static assets to S3
resource "aws_s3_object" "s3_index" {
  bucket       = aws_s3_bucket.static_site_s3.id
  key          = "index.html"
  content      = file("${path.module}/static/index.html")
  content_type = "text/html"
}

resource "aws_s3_object" "s3_404" {
  bucket       = aws_s3_bucket.static_site_s3.id
  key          = "404.html"
  content      = file("${path.module}/static/404.html")
  content_type = "text/html"
}

# Outputs
output "r2_website_endpoint" {
  value = cloudflare_r2_bucket_website_configuration.r2_website.website_endpoint
}

output "s3_website_endpoint" {
  value = aws_s3_bucket_website_configuration.s3_website.website_endpoint
}

# Variables
variable "cloudflare_api_token" {
  type        = string
  description = "Cloudflare API token with R2 edit permissions"
  sensitive   = true
}

variable "cloudflare_account_id" {
  type        = string
  description = "Cloudflare account ID"
}

variable "aws_access_key" {
  type        = string
  description = "AWS access key with S3 full permissions"
  sensitive   = true
}

variable "aws_secret_key" {
  type        = string
  description = "AWS secret key"
  sensitive   = true
}

import argparse
from dataclasses import dataclass
from typing import Optional

# Pricing data as of June 2024, verified against official provider pricing pages
R2_PRICING = {
    "storage_per_gb": 0.015,
    "class-a-requests_per_1k": 0.004,  # Write/delete requests
    "class-b-requests_per_1k": 0.0004, # Read requests
    "egress_per_gb": 0.0  # Zero egress fees
}

S3_PRICING = {
    "storage_per_gb": 0.023,
    "standard_ia_storage_per_gb": 0.0125,  # Infrequent access for assets >30 days
    "egress_per_gb": 0.09,  # First 10TB/month, then $0.085
    "get_requests_per_1k": 0.0004,
    "put_requests_per_1k": 0.005,
    "cloudfront_egress_per_gb": 0.085  # If using CloudFront with S3
}

@dataclass
class StaticSiteUsage:
    storage_gb: float  # Total storage used in GB
    monthly_egress_gb: float  # Total egress per month in GB
    monthly_get_requests: int  # Number of read requests per month
    monthly_put_requests: int  # Number of write requests per month
    assets_older_than_30d_gb: float  # Storage eligible for S3 IA
    use_cloudfront: bool  # Whether S3 uses CloudFront for egress

class CostCalculator:
    def __init__(self, usage: StaticSiteUsage):
        self.usage = usage

    def calculate_r2_cost(self) -> float:
        """Calculate total monthly cost for Cloudflare R2"""
        storage_cost = self.usage.storage_gb * R2_PRICING["storage_per_gb"]
        # Class B requests: get requests, Class A: put requests
        class_b_cost = (self.usage.monthly_get_requests / 1000) * R2_PRICING["class-b-requests_per_1k"]
        class_a_cost = (self.usage.monthly_put_requests / 1000) * R2_PRICING["class-a-requests_per_1k"]
        egress_cost = self.usage.monthly_egress_gb * R2_PRICING["egress_per_gb"]
        return round(storage_cost + class_b_cost + class_a_cost + egress_cost, 2)

    def calculate_s3_cost(self) -> float:
        """Calculate total monthly cost for AWS S3 Standard + optional CloudFront"""
        # Split storage between Standard and IA if eligible
        standard_storage = self.usage.storage_gb - self.usage.assets_older_than_30d_gb
        ia_storage = self.usage.assets_older_than_30d_gb
        storage_cost = (standard_storage * S3_PRICING["storage_per_gb"]) + (ia_storage * S3_PRICING["standard_ia_storage_per_gb"])
        # Request costs
        get_cost = (self.usage.monthly_get_requests / 1000) * S3_PRICING["get_requests_per_1k"]
        put_cost = (self.usage.monthly_put_requests / 1000) * S3_PRICING["put_requests_per_1k"]
        # Egress cost: use CloudFront if enabled, else direct S3 egress
        egress_rate = S3_PRICING["cloudfront_egress_per_gb"] if self.usage.use_cloudfront else S3_PRICING["egress_per_gb"]
        egress_cost = self.usage.monthly_egress_gb * egress_rate
        return round(storage_cost + get_cost + put_cost + egress_cost, 2)

    def print_comparison(self):
        r2_cost = self.calculate_r2_cost()
        s3_cost = self.calculate_s3_cost()
        savings = s3_cost - r2_cost
        savings_pct = (savings / s3_cost * 100) if s3_cost > 0 else 0

        print("=== Monthly Cost Comparison ===")
        print(f"Storage: {self.usage.storage_gb}GB, Egress: {self.usage.monthly_egress_gb}GB/month")
        print(f"R2 Cost: ${r2_cost}")
        print(f"S3 Cost: ${s3_cost} (CloudFront: {self.usage.use_cloudfront})")
        print(f"Monthly Savings with R2: ${round(savings, 2)} ({round(savings_pct, 1)}%)")
        if savings > 0:
            print(f"Annual Savings: ${round(savings * 12, 2)}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Calculate monthly static hosting costs for R2 vs S3")
    parser.add_argument("--storage-gb", type=float, required=True, help="Total storage in GB")
    parser.add_argument("--egress-gb", type=float, required=True, help="Monthly egress in GB")
    parser.add_argument("--get-requests", type=int, default=1000000, help="Monthly GET requests")
    parser.add_argument("--put-requests", type=int, default=100, help="Monthly PUT requests")
    parser.add_argument("--ia-storage-gb", type=float, default=0, help="Storage >30 days for S3 IA")
    parser.add_argument("--use-cloudfront", action="store_true", help="Enable CloudFront for S3 egress")
    args = parser.parse_args()

    usage = StaticSiteUsage(
        storage_gb=args.storage_gb,
        monthly_egress_gb=args.egress_gb,
        monthly_get_requests=args.get_requests,
        monthly_put_requests=args.put_requests,
        assets_older_than_30d_gb=args.ia_storage_gb,
        use_cloudfront=args.use_cloudfront
    )

    calculator = CostCalculator(usage)
    calculator.print_comparison()

    # Example: Run with --storage-gb 1000 --egress-gb 10000 --ia-storage-gb 400
    # Output: R2: $19.4, S3: $928, Savings $908.6/month

// Node.js example: Upload static asset to R2 using S3-compatible SDK
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
const r2Client = new S3Client({
  endpoint: "https://your-account-id.r2.cloudflarestorage.com",
  region: "auto",
  credentials: {
    accessKeyId: process.env.R2_ACCESS_KEY,
    secretAccessKey: process.env.R2_SECRET_KEY,
  },
});
async function uploadAsset(key, body, contentType) {
  await r2Client.send(new PutObjectCommand({
    Bucket: "static-hosting-bench-r2",
    Key: key,
    Body: body,
    ContentType: contentType,
  }));
}

# AWS CLI command to enable Intelligent Tiering on S3 bucket
aws s3api put-bucket-intelligent-tiering-configuration \
  --bucket benchmark-static-site-s3 \
  --id static-asset-tiering \
  --intelligent-tiering-configuration '{
    "Status": "Enabled",
    "Tierings": [
      {"Days": 30, "AccessTier": "ARCHIVE_ACCESS"},
      {"Days": 90, "AccessTier": "DEEP_ARCHIVE_ACCESS"}
    ]
  }'

# wrk2 command to benchmark R2 static endpoint with 1000 concurrent connections, 10k requests
wrk2 -t12 -c1000 -d60s --latency https://benchmark-static-site-r2.r2.dev/10kb-asset.html