Fallstudie: Fintech-Startup liefert Echtzeit-Währungsumrechnung im großen Maßstab

Kern-Umrechnungslogik auf Origin-Servern mit Redis-Caching-Schicht bereitgestellt, um API-Aufrufe zu minimieren und Geschwindigkeit zu maximieren.

// Node.js implementation with Redis caching
const redis = require(''redis'');
const axios = require(''axios'');

const CACHE_TTL = 300; // 5 minutes

async function convertCurrency(from, to, amount) '{'
  const cacheKey = `rate:$'{'from'}':$'{'to'}'`;

  // Check Redis cache first
  const cachedRate = await redis.get(cacheKey);
  if (cachedRate) '{'
    const rate = parseFloat(cachedRate);
    return '{'
      from, to, amount,
      converted: (amount * rate).toFixed(2),
      rate, cached: true
    '}';
  '}'

  // Cache miss: fetch from AppHighway
  const response = await axios.get(
    ''https://apphighway.com/api/v1/currency-converter'',
    '{'  params: '{'  from, to, amount: 1  '}',
       headers: '{'  Authorization: `Bearer $'{'API_KEY'}'` '}',
       timeout: 2000
    '}'
  );
  const rate = response.data.rate;

  // Store in Redis with 5-minute TTL
  await redis.setex(cacheKey, CACHE_TTL, rate.toString());

  return '{'  from, to, amount,
    converted: (amount * rate).toFixed(2),
    rate, cached: false
  '}';
'}'

module.exports = '{'  convertCurrency  '}';

CloudFlare Workers weltweit bereitgestellt, um Währungsumrechnungen vom nächsten Edge-Standort zu bedienen und Netzwerklatenz um 60% zu reduzieren.

// CloudFlare Worker: Edge currency conversion
export default '{'
  async fetch(request, env) '{'
    const url = new URL(request.url);
    const from = url.searchParams.get(''from'');
    const to = url.searchParams.get(''to'');
    const amount = parseFloat(
      url.searchParams.get(''amount'')
    );

    const cacheKey = `rate_$'{'from'}'_$'{'to'}'`;

    // Check CloudFlare KV cache
    const cachedRate = await env.CURRENCY_RATES.get(cacheKey);
    if (cachedRate) '{'
      const rate = parseFloat(cachedRate);
      return new Response(JSON.stringify('{'
        from, to, amount,
        converted: (amount * rate).toFixed(2),
        rate, source: ''edge_cache''
      '}')); 
    '}'

    // Cache miss: forward to origin
    const originResponse = await fetch(originUrl);
    const data = await originResponse.json();

    // Store rate in edge KV
    await env.CURRENCY_RATES.put(
      cacheKey, data.rate.toString(),
      '{'  expirationTtl: 300  '}'
    );

    return new Response(JSON.stringify(data));
  '}'
'}';

Admin-Dashboard zeigt Echtzeit-Kurse für 50+ Währungspaare. Batch-Endpunkt rechnet alle Paare in einem einzigen API-Aufruf statt 50 sequentiellen Aufrufen um.

// Batch currency conversion endpoint
router.post(''/convert/batch'', async (req, res) => '{'
  const '{'  base_currency, target_currencies, amount  '}' = req.body;

  // Step 1: Check Redis cache for all pairs
  const pipeline = redis.pipeline();
  target_currencies.forEach(target => '{'
    pipeline.get(`rate:$'{'base_currency'}':$'{'target'}'`);
  '}');
  const cachedRates = await pipeline.exec();

  // Step 2: Identify hits and misses
  const cacheHits = [];
  const cacheMisses = [];
  target_currencies.forEach((target, index) => '{'
    const cached = cachedRates[index][1];
    if (cached) cacheHits.push('{'  to: target, rate: parseFloat(cached)  '}');
    else cacheMisses.push(target);
  '}');

  // Step 3: Fetch missing from AppHighway
  if (cacheMisses.length > 0) '{'
    const response = await axios.post(apiUrl, '{'
      from: base_currency,
      to: cacheMisses, amount: 1
    '}');
    // Store and collect results
  '}'

  res.json('{'  base_currency, amount, conversions: results  '}');
'}');

Intelligente Ratenbegrenzung verhindert übermäßige API-Nutzung bei gleichzeitiger Aufrechterhaltung der Performance während Verkehrsspitzen.

// Rate limit optimization with sliding window
const rateLimit = require(''express-rate-limit'');
const RedisStore = require(''rate-limit-redis'');

// Tier-based rate limiting
const rateLimiters = '{'
  // Public API: 100 requests per minute per IP
  public: rateLimit('{'
    store: new RedisStore('{'  client: redis  '}'),
    windowMs: 60 * 1000,
    max: 100,
    message: ''Too many requests''
  '}'),

  // Authenticated: 500 requests per minute
  authenticated: rateLimit('{'
    store: new RedisStore('{'  client: redis  '}'),
    windowMs: 60 * 1000,
    max: 500,
    keyGenerator: (req) => req.user.id
  '}'),

  // Internal services: no rate limit
  internal: (req, res, next) => next()
'}';

// Apply based on authentication
app.use(''/api/convert'', (req, res, next) => '{'
  if (req.user) return rateLimiters.authenticated(req, res, next);
  return rateLimiters.public(req, res, next);
'}');

95% Cache-Trefferquote bedeutet, dass nur 5% der Anfragen AppHighway API treffen. Bei 250.000 Umrechnungen/Tag reduziert Caching monatliche Kosten von 3.750 $ auf 188 $, eine 95%ige Reduktion.

Edge-Cache-Treffer: 8ms Durchschnitt. Origin-Cache-Treffer: 28ms Durchschnitt. Origin-Cache-Fehltreffer: 63ms Durchschnitt. Gewichteter Durchschnitt: 11,3ms. Ohne Edge: 31ms (3x langsamer).

Legacy-Anbieter: 0,01 $ pro Transaktion. AppHighway + Infrastruktur: 0,00016 $ pro Transaktion. Pro-Transaktions-Kosten reduziert um 98,4%.