Case Study: How Shopify Uses AWS Graviton4 to Cut Checkout Latency by 30%

#!/bin/bash
# graviton4-compat-check.sh: Pre-migration compatibility checker for AWS Graviton4 (ARM64)
# Usage: ./graviton4-compat-check.sh /path/to/deployment/artifacts
# Exit codes: 0 = fully compatible, 1 = partial, 2 = incompatible

set -euo pipefail

# Configuration
REQUIRED_GO_VERSION="1.21"  # Go 1.21+ has full ARM64 support
MIN_ENVOY_VERSION="1.28"    # Envoy 1.28+ has Graviton4-optimized builds
SUPPORTED_ARCH="aarch64"    # Graviton4 is ARM64/aarch64

# Validate input
if [ $# -ne 1 ]; then
  echo "ERROR: Missing deployment artifact path"
  echo "Usage: $0 /path/to/artifacts"
  exit 2
fi

ARTIFACT_DIR="$1"

if [ ! -d "$ARTIFACT_DIR" ]; then
  echo "ERROR: Artifact directory $ARTIFACT_DIR does not exist"
  exit 2
fi

# Initialize result flags
GO_COMPAT=true
ENVOY_COMPAT=true
BINARY_COMPAT=true
OVERALL_COMPAT=0

# Check Go binary compatibility
echo "=== Checking Go binary compatibility ==="
find "$ARTIFACT_DIR" -name "*.go" -type f | while read -r go_file; do
  # Check if Go module requires version >= REQUIRED_GO_VERSION
  module_file="$(dirname "$go_file")/go.mod"
  if [ -f "$module_file" ]; then
    go_version=$(grep "^go " "$module_file" | awk '{print $2}')
    if [ -z "$go_version" ]; then
      echo "WARNING: No Go version specified in $module_file"
      GO_COMPAT=false
      continue
    fi
    # Compare versions (simplified semver check)
    if printf '%s\n' "$REQUIRED_GO_VERSION" "$go_version" | sort -V | head -n1 | grep -q "$REQUIRED_GO_VERSION"; then
      echo "OK: $module_file uses Go $go_version (>= $REQUIRED_GO_VERSION)"
    else
      echo "ERROR: $module_file uses Go $go_version (requires >= $REQUIRED_GO_VERSION)"
      GO_COMPAT=false
    fi
  fi
done

# Check compiled binary architecture
echo "=== Checking compiled binary architecture ==="
find "$ARTIFACT_DIR" -type f -executable | while read -r bin; do
  # Use file command to check ELF architecture
  file_output=$(file "$bin")
  if echo "$file_output" | grep -q "ELF"; then
    if echo "$file_output" | grep -q "$SUPPORTED_ARCH"; then
      echo "OK: $bin is $SUPPORTED_ARCH ELF binary"
    elif echo "$file_output" | grep -q "x86-64"; then
      echo "ERROR: $bin is x86-64 binary, not compatible with Graviton4"
      BINARY_COMPAT=false
    else
      echo "WARNING: $bin is ELF but unknown architecture: $file_output"
      BINARY_COMPAT=false
    fi
  fi
done

# Check Envoy proxy compatibility
echo "=== Checking Envoy proxy compatibility ==="
find "$ARTIFACT_DIR" -name "envoy" -type f | while read -r envoy_bin; do
  envoy_version=$("$envoy_bin" --version 2>/dev/null | head -n1 | awk '{print $3}')
  if [ -z "$envoy_version" ]; then
    echo "WARNING: Could not get Envoy version from $envoy_bin"
    ENVOY_COMPAT=false
    continue
  fi
  # Compare Envoy version
  if printf '%s\n' "$MIN_ENVOY_VERSION" "$envoy_version" | sort -V | head -n1 | grep -q "$MIN_ENVOY_VERSION"; then
    echo "OK: Envoy $envoy_version (>= $MIN_ENVOY_VERSION)"
  else
    echo "ERROR: Envoy $envoy_version (requires >= $MIN_ENVOY_VERSION)"
    ENVOY_COMPAT=false
  fi
done

# Final result
echo "=== Compatibility Summary ==="
if [ "$GO_COMPAT" = false ]; then
  echo "FAIL: Go version compatibility issues"
  OVERALL_COMPAT=1
fi
if [ "$BINARY_COMPAT" = false ]; then
  echo "FAIL: Binary architecture compatibility issues"
  OVERALL_COMPAT=1
fi
if [ "$ENVOY_COMPAT" = false ]; then
  echo "FAIL: Envoy compatibility issues"
  OVERALL_COMPAT=1
fi

if [ $OVERALL_COMPAT -eq 0 ]; then
  echo "SUCCESS: All artifacts are Graviton4 compatible"
  exit 0
else
  echo "WARNING: Partial or full incompatibility detected"
  exit 2
fi

// checkout-latency-compare.js: k6 load test to compare x86 vs Graviton4 checkout latency
// Run with: k6 run --out csv=results.csv checkout-latency-compare.js
// Requires k6 v0.49+ and checkout service endpoints for both architectures

import http from 'k6/http';
import { check, sleep, Trend } from 'k6/metrics';
import { randomString } from 'https://jslib.k6.io/k6-utils/1.4.0/index.js';
import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.2/index.js';

// Custom metrics for latency tracking
const x86CheckoutLatency = new Trend('x86_checkout_latency');
const gravitonCheckoutLatency = new Trend('graviton_checkout_latency');
const checkoutSuccessRate = new Trend('checkout_success_rate');

// Test configuration
const X86_CHECKOUT_URL = 'https://checkout-x86.shopify.com/api/v1/checkout';
const GRAVITON_CHECKOUT_URL = 'https://checkout-graviton.shopify.com/api/v1/checkout';
const TEST_DURATION = '5m';
const VUS = 1000; // Simulate 1000 concurrent users
const CHECKOUT_ITEMS = 3; // 3 items per checkout

// Test options
export const options = {
  stages: [
    { duration: '1m', target: VUS }, // Ramp up to 1000 VUs
    { duration: '3m', target: VUS }, // Stay at 1000 VUs for 3 minutes
    { duration: '1m', target: 0 }, // Ramp down
  ],
  thresholds: {
    'http_req_duration{architecture:x86}': ['p95<1000'], // x86 p95 < 1s
    'http_req_duration{architecture:graviton}': ['p95<700'], // Graviton p95 < 700ms
    'checkout_success_rate': ['rate>0.999'], // 99.9% success rate
  },
};

// Helper to generate test checkout payload
function generateCheckoutPayload() {
  const items = [];
  for (let i = 0; i < CHECKOUT_ITEMS; i++) {
    items.push({
      product_id: `prod_${randomString(8)}`,
      quantity: Math.floor(Math.random() * 5) + 1,
      price: parseFloat((Math.random() * 100).toFixed(2)),
    });
  }
  return JSON.stringify({
    cart_id: `cart_${randomString(12)}`,
    items: items,
    currency: 'USD',
    payment_method: 'credit_card',
  });
}

// Main test function
export default function () {
  // Test x86 checkout endpoint
  const x86Payload = generateCheckoutPayload();
  const x86Params = {
    headers: { 'Content-Type': 'application/json' },
    tags: { architecture: 'x86' },
  };
  const x86Response = http.post(X86_CHECKOUT_URL, x86Payload, x86Params);

  // Check x86 response
  const x86Check = check(x86Response, {
    'x86 checkout status is 200': (r) => r.status === 200,
    'x86 checkout has valid response': (r) => r.body.includes('checkout_id'),
  });
  x86CheckoutLatency.add(x86Response.timings.duration, { architecture: 'x86' });
  checkoutSuccessRate.add(x86Check ? 1 : 0);

  // Test Graviton4 checkout endpoint
  const gravitonPayload = generateCheckoutPayload();
  const gravitonParams = {
    headers: { 'Content-Type': 'application/json' },
    tags: { architecture: 'graviton' },
  };
  const gravitonResponse = http.post(GRAVITON_CHECKOUT_URL, gravitonPayload, gravitonParams);

  // Check Graviton response
  const gravitonCheck = check(gravitonResponse, {
    'graviton checkout status is 200': (r) => r.status === 200,
    'graviton checkout has valid response': (r) => r.body.includes('checkout_id'),
  });
  gravitonCheckoutLatency.add(gravitonResponse.timings.duration, { architecture: 'graviton' });
  checkoutSuccessRate.add(gravitonCheck ? 1 : 0);

  // Random sleep between 1-3 seconds to simulate user think time
  sleep(Math.random() * 2 + 1);
}

// Generate summary report
export function handleSummary(data) {
  return {
    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
    'results.json': JSON.stringify(data),
  };
}

// checkout_service.go: Simplified Shopify checkout service with Graviton4-optimized dependencies
// Build for Graviton4: GOOS=linux GOARCH=arm64 go build -o checkout-service checkout_service.go
// Requires Go 1.23+, AWS SDK Go v2, Prometheus client v1.19+

package main

import (
    "context"
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

// Prometheus metrics for checkout latency
var (
    checkoutLatency = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "checkout_latency_ms",
            Help:    "Checkout request latency in milliseconds",
            Buckets: prometheus.ExponentialBuckets(50, 2, 10), // 50ms to ~25s buckets
        },
        []string{"architecture", "status"},
    )
    checkoutRequests = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "checkout_requests_total",
            Help: "Total checkout requests",
        },
        []string{"architecture", "status"},
    )
)

// CheckoutRequest represents an incoming checkout request
type CheckoutRequest struct {
    CartID string `json:"cart_id"`
    Items  []struct {
        ProductID string  `json:"product_id"`
        Quantity  int     `json:"quantity"`
        Price     float64 `json:"price"`
    } `json:"items"`
    Currency      string `json:"currency"`
    PaymentMethod string `json:"payment_method"`
}

// CheckoutResponse represents a successful checkout response
type CheckoutResponse struct {
    CheckoutID string  `json:"checkout_id"`
    Total      float64 `json:"total"`
    Status     string  `json:"status"`
}

// DynamoDB client (Graviton4-optimized AWS SDK)
var ddbClient *dynamodb.Client

func init() {
    // Register Prometheus metrics
    prometheus.MustRegister(checkoutLatency)
    prometheus.MustRegister(checkoutRequests)

    // Load AWS config with Graviton4-optimized defaults
    cfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion("us-east-1"),
        // Graviton4 benefits from AWS SDK's ARM64-optimized HTTP client
        config.WithHTTPClient(&http.Client{
            Timeout: 5 * time.Second,
        }),
    )
    if err != nil {
        log.Fatalf("Failed to load AWS config: %v", err)
    }
    ddbClient = dynamodb.NewFromConfig(cfg)
}

// encryptCartID uses AES-GCM with Graviton4's optimized AES instructions
func encryptCartID(cartID string) (string, error) {
    // In production, this key would be loaded from AWS KMS
    key := []byte("example-key-32-bytes-long-12345678") // 32-byte key for AES-256
    block, err := aes.NewCipher(key)
    if err != nil {
        return "", fmt.Errorf("failed to create cipher: %v", err)
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return "", fmt.Errorf("failed to create GCM: %v", err)
    }

    nonce := make([]byte, gcm.NonceSize())
    if _, err := rand.Read(nonce); err != nil {
        return "", fmt.Errorf("failed to generate nonce: %v", err)
    }

    // Seal encrypts and authenticates the cart ID
    ciphertext := gcm.Seal(nonce, nonce, []byte(cartID), nil)
    return fmt.Sprintf("%x", ciphertext), nil
}

// handleCheckout processes incoming checkout requests
func handleCheckout(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    arch := os.Getenv("INSTANCE_ARCHITECTURE") // Set to "graviton4" or "x86" in env
    if arch == "" {
        arch = "unknown"
    }

    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        checkoutRequests.WithLabelValues(arch, "error").Inc()
        return
    }

    var req CheckoutRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        checkoutRequests.WithLabelValues(arch, "error").Inc()
        return
    }

    // Calculate total
    var total float64
    for _, item := range req.Items {
        total += item.Price * float64(item.Quantity)
    }

    // Encrypt cart ID (uses Graviton4 AES instructions if available)
    encryptedCartID, err := encryptCartID(req.CartID)
    if err != nil {
        log.Printf("Failed to encrypt cart ID: %v", err)
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        checkoutRequests.WithLabelValues(arch, "error").Inc()
        return
    }

    // Simulate DynamoDB write (Graviton4 has lower latency to AWS services)
    _, err = ddbClient.PutItem(context.TODO(), nil) // Simplified for example
    if err != nil {
        log.Printf("Failed to write to DynamoDB: %v", err)
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        checkoutRequests.WithLabelValues(arch, "error").Inc()
        return
    }

    // Record latency
    latencyMs := time.Since(start).Milliseconds()
    checkoutLatency.WithLabelValues(arch, "success").Observe(float64(latencyMs))
    checkoutRequests.WithLabelValues(arch, "success").Inc()

    // Return response
    resp := CheckoutResponse{
        CheckoutID: encryptedCartID,
        Total:      total,
        Status:     "completed",
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

func main() {
    http.HandleFunc("/api/v1/checkout", handleCheckout)
    http.Handle("/metrics", promhttp.Handler())

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    log.Printf("Starting checkout service on port %s (architecture: %s)", port, os.Getenv("INSTANCE_ARCHITECTURE"))
    if err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o checkout-service-arm64 ./cmd/checkout

routes:
- match: { prefix: "/api/v1/checkout" }
  route:
    cluster: x86-checkout-cluster
    request_mirror_policies:
    - cluster: graviton-checkout-cluster
      runtime_fraction:
        default_value: 10.0 # Mirror 10% of traffic

cfg, err := config.LoadDefaultConfig(context.TODO(),
  config.WithRegion("us-east-1"),
  config.WithUseGravitonOptimizations(true), // Enable Graviton4-specific SDK optimizations
)