Cloud-Datenbank auswählen: Decision-Framework für Architekten (2026)

graph TD
    Q1{Was ist dein
primäres Access-Pattern?}
    Q1 --> Q1A[Key-Value / Document
Lookups]
    Q1 --> Q1B[Komplexe relationale
Queries / Joins]
    Q1 --> Q1C[Time-Series
Append-heavy]
    Q1 --> Q1D[Graph-Traversal]
    Q1 --> Q1E[Analytisch /
Aggregation]
    Q1 --> Q1F[Semantische Ähnlichkeit
Vector-Search]

    Q1A --> Q2A{Scale?}
    Q2A -->|< 100M Zeilen, kein Extrem-Scale| RDB[PostgreSQL / MySQL]
    Q2A -->|Massive Scale, variables Schema| NOSQL[DynamoDB / Firestore]

    Q1B --> RDB
    Q1C --> TSDB[TimescaleDB / InfluxDB /
Amazon Timestream]
    Q1D --> GDB[Neo4j / Amazon Neptune /
ArangoDB]
    Q1E --> OLAP[BigQuery / Redshift /
Snowflake / Databricks]
    Q1F --> VDB[Pinecone / Weaviate /
pgvector]

resource "aws_rds_cluster" "harbinger" {
  cluster_identifier     = "harbinger-prod"
  engine                 = "aurora-postgresql"
  engine_version         = "15.4"
  database_name          = "harbinger"
  master_username        = "admin"
  manage_master_user_password = true  # Secrets-Manager-Integration
  
  serverlessv2_scaling_configuration {
    min_capacity = 0.5
    max_capacity = 64
  }

  backup_retention_period = 14
  preferred_backup_window = "02:00-03:00"
  
  enabled_cloudwatch_logs_exports = ["postgresql"]
  
  deletion_protection = true
  skip_final_snapshot = false
  final_snapshot_identifier = "harbinger-prod-final"

  tags = {
    Environment = "production"
  }
}

# Mehrere Entity-Typen in einer DynamoDB-Tabelle
# mit Composite-Keys und GSIs

table_schema = {
    "TableName": "harbinger-events",
    "KeySchema": [
        {"AttributeName": "PK", "KeyType": "HASH"},   # z.B. COUNTRY#US
        {"AttributeName": "SK", "KeyType": "RANGE"},  # z.B. EVENT#2024-01-15#uuid
    ],
    "GlobalSecondaryIndexes": [
        {
            "IndexName": "EventTypeIndex",
            "KeySchema": [
                {"AttributeName": "GSI1PK", "KeyType": "HASH"},  # EVENT_TYPE#CONFLICT
                {"AttributeName": "GSI1SK", "KeyType": "RANGE"}, # DATE#2024-01-15
            ],
            "Projection": {"ProjectionType": "ALL"},
        }
    ],
    "BillingMode": "PAY_PER_REQUEST",
}

# Access-Patterns, die das ermöglicht:
# 1. Alle Events für ein Land: PK=COUNTRY#US, SK begins_with EVENT#
# 2. Events nach Typ: GSI1PK=EVENT_TYPE#CONFLICT, GSI1SK between Dates
# 3. Einzelnes Event: PK=COUNTRY#US, SK=EVENT#2024-01-15#abc123

-- Hypertable für geopolitische Risk-Scores
CREATE TABLE risk_scores (
    time        TIMESTAMPTZ NOT NULL,
    country     TEXT NOT NULL,
    risk_score  FLOAT NOT NULL,
    event_count INTEGER,
    source      TEXT
);

-- In Hypertable umwandeln, partitioniert nach Zeit
SELECT create_hypertable('risk_scores', 'time', chunk_time_interval => INTERVAL '1 day');

-- Compression-Policy hinzufügen (Chunks älter als 7 Tage)
ALTER TABLE risk_scores SET (
    timescaledb.compress,
    timescaledb.compress_segmentby = 'country'
);
SELECT add_compression_policy('risk_scores', INTERVAL '7 days');

-- Retention-Policy (Daten älter als 2 Jahre droppen)
SELECT add_retention_policy('risk_scores', INTERVAL '2 years');

-- Query: Risk-Score-Trend mit Gap-Filling
SELECT
    time_bucket_gapfill('1 hour', time) AS bucket,
    country,
    AVG(risk_score) as avg_risk,
    locf(AVG(risk_score)) as filled_risk  -- last observation carried forward
FROM risk_scores
WHERE country = 'UA'
    AND time > NOW() - INTERVAL '30 days'
GROUP BY bucket, country
ORDER BY bucket;

-- Tabellen partitionieren, um gescannte Bytes zu reduzieren
CREATE TABLE harbinger_prod.events.geopolitical
PARTITION BY DATE(event_date)
CLUSTER BY country_code, event_type
AS SELECT * FROM staging.raw_events;

-- Partition-Filter in Queries verwenden (Full-Table-Scans vermeiden)
SELECT country_code, COUNT(*) as event_count
FROM harbinger_prod.events.geopolitical
WHERE DATE(event_date) BETWEEN '2024-01-01' AND '2024-03-31'  -- Partition-Pruning
GROUP BY country_code;

-- pgvector aktivieren
CREATE EXTENSION IF NOT EXISTS vector;

-- Artikel-Embeddings neben Metadaten speichern
CREATE TABLE article_embeddings (
    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    article_id  TEXT NOT NULL,
    title       TEXT NOT NULL,
    country     TEXT,
    event_date  DATE,
    embedding   vector(1536),  -- Dimensionen OpenAI text-embedding-3-small
    created_at  TIMESTAMPTZ DEFAULT NOW()
);

-- HNSW-Index für schnelle Approximate-Nearest-Neighbour-Search
CREATE INDEX ON article_embeddings USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- Semantic Search: ähnliche geopolitische Events finden
SELECT
    article_id,
    title,
    country,
    event_date,
    1 - (embedding <=> $1::vector) AS similarity
FROM article_embeddings
WHERE country = 'UA'  -- pre-filter by country
    AND event_date > '2024-01-01'
ORDER BY embedding <=> $1::vector
LIMIT 20;

graph LR
    APP[Application-Layer]
    
    APP --> PG[(PostgreSQL
User-Daten, Config,
transaktional)]
    APP --> DDB[(DynamoDB
High-Throughput
API-Responses)]
    APP --> REDIS[(Redis
Cache, Sessions,
Rate-Limiting)]
    APP --> PGV[(pgvector
Semantische Suche
RAG)]
    APP --> BQ[(BigQuery
Analytics,
BI-Queries)]
    APP --> TS[(TimescaleDB
Metrics,
Risk-Scores)]