Architekturüberblick

Architektur auf hoher Ebene

Greentic folgt einer geschichteten Architektur mit klarer Trennung der Zuständigkeiten:

┌─────────────────────────────────────────────────────────┐
│                    Messaging Channels                    │
│         (Slack, Teams, Telegram, WhatsApp, WebChat)     │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                    Gateway (HTTP)                       │
│                 Public Endpoint Router                   │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                    greentic-runner                       │
│           (Production Runtime Host)                      │
│  ┌─────────────────────────────────────────────────┐    │
│  │              Flow Executor                       │    │
│  │         (Wasmtime Component Model)              │    │
│  └─────────────────────────────────────────────────┘    │
│  ┌─────────────────────────────────────────────────┐    │
│  │           Session Manager                        │    │
│  │         (Memory / Redis)                         │    │
│  └─────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                    WASM Components                       │
│    (Flows, Providers, MCP Tools, Custom Components)     │
└─────────────────────────────────────────────────────────┘

Kernkomponenten

greentic-runner

Die zentrale Produktions-Runtime, die Flows hostet und ausführt, Sessions verwaltet und alle Plattformdienste koordiniert.

greentic-flow

Flow-Schemadefinition, Intermediate Representation (IR), Loader und Validator für .ygtc-Dateien.

greentic-pack

Pack-Builder-CLI zum Erstellen signierter .gtpack-Archive mit Flows, Komponenten und Assets.

greentic-component

CLI zum Erstellen von Komponenten und Runtime-Hilfsprogramme zum Bauen von WASM-Komponenten.

Runtime-Stack

Ebene	Technologie	Zweck
WASM Runtime	Wasmtime v41	Ausführung des Component Model
Async Runtime	Tokio v1	Asynchrone I/O, Task-Scheduling
HTTP Server	Axum v0.8	REST-API, Webhooks
Message Bus	Internal event bus	Ereignisverteilung, Pub/Sub
Session Store	Memory/Redis	Persistenz des Flow-Zustands
Secrets	AWS/Azure/GCP/Vault	Verwaltung von Anmeldedaten

Datenfluss

Eingehender Nachrichtenfluss

1. External Message (e.g., Slack)
   │
2. Webhook Handler (Provider Ingress)
   │
3. Message bus: greentic.messaging.ingress.{env}.{tenant}.{team}.{channel}
   │
4. Flow Router (tenant/team resolution)
   │
5. Flow Executor (WASM component execution)
   │
6. Session State Update
   │
7. Reply/Action Nodes
   │
8. Message bus: greentic.messaging.egress.{env}.{tenant}.{team}.{channel}
   │
9. Provider Egress → External Service

Pack-Ladefluss

1. Bundle Configuration (greentic.demo.yaml)
   │
2. Pack Resolver (local/OCI registry)
   │
3. Signature Verification (ed25519-dalek)
   │
4. CBOR Metadata Parsing
   │
5. WASM Component Instantiation
   │
6. WIT Interface Binding
   │
7. Runtime Registration

Multi-Tenancy-Modell

Greentic implementiert Tenant-Isolation auf jeder Ebene:

Tenant
  └── Environment (prod, staging, dev)
        └── Team
              └── Channel (messaging provider instance)
                    └── Session (user conversation state)

TenantCtx

Die TenantCtx-Struktur fließt durch alle Operationen:

pub struct TenantCtx {
    pub tenant_id: String,
    pub env_id: String,
    pub team_id: Option<String>,
}

WIT-Schnittstellenarchitektur

Greentic verwendet die Spezifikation WebAssembly Interface Types (WIT) zur Definition von Komponentenschnittstellen:

// greentic-interfaces/wit/greentic/component@0.6.0/package.wit
package greentic:component@0.6.0;

interface control {
  should-cancel: func() -> bool;
  yield-now: func();
}

interface node {
  use greentic:types-core/core@0.6.0.{capability-id, component-id, flow-id, node-error, step-id, tenant-ctx};

  record invocation-envelope {
    ctx: tenant-ctx,
    flow-id: flow-id,
    step-id: step-id,
    component-id: component-id,
    attempt: u32,
    payload-cbor: list<u8>,
    metadata-cbor: option<list<u8>>,
  }

  record invocation-result {
    ok: bool,
    output-cbor: list<u8>,
    output-metadata-cbor: option<list<u8>>,
  }

  variant schema-source {
    cbor-schema-id(string),
    inline-cbor(list<u8>),
    ref-pack-path(string),
    ref-uri(string),
  }

  record io-schema {
    schema: schema-source,
    content-type: string,
    schema-version: option<string>,
  }

  record example {
    title: string,
    input-cbor: list<u8>,
    output-cbor: list<u8>,
  }

  record schema-ref {
    id: string,
    content-type: string,
    blake3-hash: string,
    version: string,
    bytes: option<list<u8>>,
    uri: option<string>,
  }

  record setup-example {
    title: string,
    answers-cbor: list<u8>,
  }

  record setup-template-scaffold {
    template-ref: string,
    output-layout: option<string>,
  }

  variant setup-output {
    config-only,
    template-scaffold(setup-template-scaffold),
  }

  record setup-contract {
    qa-spec: schema-source,
    answers-schema: schema-source,
    examples: list<setup-example>,
    outputs: list<setup-output>,
  }

  record op {
    name: string,
    summary: option<string>,
    input: io-schema,
    output: io-schema,
    examples: list<example>,
  }

  record component-descriptor {
    name: string,
    version: string,
    summary: option<string>,
    capabilities: list<capability-id>,
    ops: list<op>,
    schemas: list<schema-ref>,
    setup: option<setup-contract>,
  }

  describe: func() -> component-descriptor;
  invoke: func(op: string, envelope: invocation-envelope) -> result<invocation-result, node-error>;
}

world component {
  import control;
  export node;
}

Service-Abhängigkeiten

greentic-types  ─────────────────────────── (foundation)
    ↑
greentic-telemetry
greentic-interfaces ← greentic-types
greentic-config ← greentic-types
    ↑
greentic-session ← greentic-types
greentic-state ← greentic-types + greentic-interfaces
greentic-flow ← greentic-interfaces + greentic-types
    ↑
greentic-pack ← greentic-flow + greentic-types
greentic-component ← greentic-interfaces + greentic-types
greentic-mcp ← greentic-interfaces + greentic-types
    ↑
greentic-runner ← ALL of the above

Observability

Greentic verwendet OpenTelemetry für verteiltes Tracing und Metriken:

• Tracing: OTLP-Exporter für verteilte Trace-Korrelation
• Metrics: Flow-Ausführungszeiten, Nachrichtendurchsatz, Fehlerraten
• Logging: Strukturiertes Logging mit Trace-Kontext

Nächste Schritte

• Flows - Lernen Sie Flow-Definitionen kennen
• Packs - Verstehen Sie die Pack-Struktur
• Komponenten - Erstellen Sie benutzerdefinierte WASM-Komponenten