Domain cloud native

Cloud-Native Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule	Design Constraint	Rust Implication
12-Factor	Config from env	Environment-based config
Observability	Metrics + traces	tracing + opentelemetry
Health checks	Liveness/readiness	Dedicated endpoints
Graceful shutdown	Clean termination	Signal handling
Horizontal scale	Stateless design	No local state
Container-friendly	Small binaries	Release optimization

---

Critical Constraints

Stateless Design

RULE: No local persistent state
WHY: Pods can be killed/rescheduled anytime
RUST: External state (Redis, DB), no static mut

Graceful Shutdown

RULE: Handle SIGTERM, drain connections
WHY: Zero-downtime deployments
RUST: tokio::signal + graceful shutdown

Observability

RULE: Every request must be traceable
WHY: Debugging distributed systems
RUST: tracing spans, opentelemetry export

---

Trace Down ↓

From constraints to design (Layer 2):

"Need distributed tracing"
    ↓ m12-lifecycle: Span lifecycle
    ↓ tracing + opentelemetry

"Need graceful shutdown"
    ↓ m07-concurrency: Signal handling
    ↓ m12-lifecycle: Connection draining

"Need health checks"
    ↓ domain-web: HTTP endpoints
    ↓ m06-error-handling: Health status

---

Key Crates

Purpose	Crate
gRPC	tonic
Kubernetes	kube, kube-runtime
Docker	bollard
Tracing	tracing, opentelemetry
Metrics	prometheus, metrics
Config	config, figment
Health	HTTP endpoints

Design Patterns

Pattern	Purpose	Implementation
gRPC services	Service mesh	tonic + tower
K8s operators	Custom resources	kube-runtime Controller
Observability	Debugging	tracing + OTEL
Health checks	Orchestration	/health, /ready
Config	12-factor	Env vars + secrets

Code Pattern: Graceful Shutdown

use tokio::signal;

async fn run_server() -> anyhow::Result<()> {
    let app = Router::new()
        .route("/health", get(health))
        .route("/ready", get(ready));

    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .with_graceful_shutdown(shutdown_signal())
        .await?;

    Ok(())
}

async fn shutdown_signal() {
    signal::ctrl_c().await.expect("failed to listen for ctrl+c");
    tracing::info!("shutdown signal received");
}

Health Check Pattern

async fn health() -> StatusCode {
    StatusCode::OK
}

async fn ready(State(db): State<Arc<DbPool>>) -> StatusCode {
    match db.ping().await {
        Ok(_) => StatusCode::OK,
        Err(_) => StatusCode::SERVICE_UNAVAILABLE,
    }
}

---

Common Mistakes

Mistake	Domain Violation	Fix
Local file state	Not stateless	External storage
No SIGTERM handling	Hard kills	Graceful shutdown
No tracing	Can't debug	tracing spans
Static config	Not 12-factor	Env vars

---

Trace to Layer 1

Constraint	Layer 2 Pattern	Layer 1 Implementation
Stateless	External state	Arc<Client> for external
Graceful shutdown	Signal handling	tokio::signal
Tracing	Span lifecycle	tracing + OTEL
Health checks	HTTP endpoints	Dedicated routes

---

Related Skills

When	See
Async patterns	m07-concurrency
HTTP endpoints	domain-web
Error handling	m13-domain-error
Resource lifecycle	m12-lifecycle