docs: create rfc 008 Dataplane

apps/dashboard/lib/trpc/routers/key/delete.ts

@@ -76,7 +76,7 @@ export const deleteKeys = t.procedure
         );
       })
       .catch((err) => {
-        console.error(err)
+        console.error(err);
         throw new TRPCError({
           code: "INTERNAL_SERVER_ERROR",
           message: "We are unable to delete the key. Please try again or contact [email protected]",

apps/engineering/content/rfcs/0008-dataplane.mdx

@@ -0,0 +1,111 @@
+---
+title: 0008 Dataplane
+description: Global Unkey Deployment Architecture
+date: 2025-01-26
+authors:
+  - Andreas Thomas
+---
+
+
+We need to design a globally distributed architecture for Unkey where the dataplane can operate independently of the primary database for improved availability.
+
+## Goals
+
+- Achieve 100% dataplane availability independent of primary database
+- Provide fast access to dynamic data across global regions
+- Propagate data across the system quickly
+- Minimize load on expensive storage
+- Enable efficient cache invalidation
+- Can run on any cloud or on premise
+
+## Options
+
+### 1. Direct S3 + In-Memory Cache with SWR
+
+```ascii
+┌─────────────────────┐     ┌─────────┐
+│ Gateway             │     │         │
+│ ┌───────────────┐   │────►│   S3    │
+│ │ Memory Cache  │   │     │         │
+│ └───────────────┘   │     │         │
+└─────────────────────┘     └─────────┘
+```
+
+#### Pros
+- Simple, straightforward design
+- Low architectural complexity
+
+#### Cons
+- Cache invalidation requires communication with all machines or really low TTLs (\<10s)
+- Inefficient cache refresh patterns
+- High load on S3 due to concurrent SWR requests from multiple machines
+
+### 2. S3 + In-Memory Cache with Gossip Protocol
+
+```ascii
+┌─────────────────────┐
+│ Gateway             │
+│ ┌───────────────┐   │──┐
+│ │ Memory Cache  │   │  │
+│ └───────────────┘   │  │
+└─────────────────────┘  │
+         ▲               │
+         │ Gossip        │    ┌─────────┐
+         ▼               ├───►│         │
+┌─────────────────────┐  │    │   S3    │
+│ Gateway             │  │    │         │
+│ ┌───────────────┐   │──┘    └─────────┘
+│ │ Memory Cache  │   │
+│ └───────────────┘   │
+└─────────────────────┘
+```
+
+If we had global fast and efficient eviction, we could set much higher TTLs.
+
+#### Pros
+- Efficient cache invalidation through gossip, allowing higher TTLs
+- Reduced load on primary storage
+- Only need to notify one node for changes
+
+#### Cons
+- Need to implement ordering mechanism (timestamps/Lamport clocks)
+- More complex system architecture
+- Global gossip cluster management overhead
+
+### 3. S3 + Dedicated Cache Layer
+
+```ascii
+┌─────────────────┐
+│ Gateway 1       │───┐
+└─────────────────┘   │
+                      │
+┌─────────────────┐   │    ┌────────────┐
+│ Gateway 2       │───┼───►│   Load     │    ┌────────────┐
+└─────────────────┘   │    │  Balancer  │───►│ Cache      │──┐
+                      │    │            │    │ Node 1     │  │
+┌─────────────────┐   │    │            │    └────────────┘  │
+│ Gateway 3       │───┤    │            │                    │    ┌─────────┐
+└─────────────────┘   │    │            │                    ├───►│   S3    │
+                      ├───►│            │    ┌────────────┐  │    └─────────┘
+┌─────────────────┐   │    │            │───►│ Cache      │──┘
+│ Gateway 4       │───┤    │            │    │ Node 2     │
+└─────────────────┘   │    └────────────┘    └────────────┘
+                      │
+┌─────────────────┐   │
+│ Gateway n       │───┘
+└─────────────────┘
+```
+
+Gateways still use an in-memory SWR cache. The cache nodes help reduce the cost
+and latency of S3, but will likely have the same freshness/staleness as the
+gateways. TBD..
+
+Everything here, except the S3 bucket, would be duplicated per region.
+
+#### Pros
+- Better cache retention due to less frequent reboots
+- Optional global eviction via gossip/kafka later
+- Maybe we only need 1 S3 region now instead of replicating it
+
+#### Cons
+- Additional infrastructure to manage