Domain Cloud Native

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when building cloud-native apps. Keywords: kubernetes, k8s, docker, container, grpc, tonic, microservice, service mesh, observability, tracing, metrics, health check, cloud, deployment, 云原生, 微服务, 容器

Instructions onlyDevOps & Cloud Software Development

AI-generated overview

Guides Rust cloud-native service design with 12-factor, stateless, observability and graceful-shutdown constraints.

What it does: This skill supplies domain constraints for building cloud-native applications, mainly in Rust. It maps rules such as 12-factor configuration, stateless design, health checks, graceful shutdown and observability to design implications and crate choices. It includes code patterns for graceful shutdown and health/readiness endpoints, plus tables of common mistakes and related skills.
When to use it: Use it when designing or reviewing cloud-native services that run in containers or Kubernetes. It fits work needing stateless design, distributed tracing, metrics, health checks or graceful shutdown. It is guidance only and produces no files or scripts.
Requirements: No scripts or special tooling are required; it is an instructions-only document. The code patterns reference Rust crates such as tonic, kube, tracing, opentelemetry, prometheus, config and axum, but nothing needs to be installed to read the guidance.

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 stateWHY: Pods can be killed/rescheduled anytimeRUST: External state (Redis, DB), no static mut

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

Graceful Shutdown

RULE: Handle SIGTERM, drain connectionsWHY: Zero-downtime deploymentsRUST: tokio::signal + graceful shutdown

RULE: Handle SIGTERM, drain connectionsWHY: Zero-downtime deploymentsRUST: tokio::signal + graceful shutdown

Observability

RULE: Every request must be traceableWHY: Debugging distributed systemsRUST: tracing spans, opentelemetry export

RULE: Every request must be traceableWHY: Debugging distributed systemsRUST: 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

"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

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

rust

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");}

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

rust

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,    }}

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

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

Source and attribution

Source:actionbook/rust-skillsinskills/domain-cloud-nativeat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

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

Domain Cloud Native

Cloud-Native Domain

Domain Constraints → Design Implications

Critical Constraints

Stateless Design

Graceful Shutdown

Observability

Trace Down ↓

Key Crates

Design Patterns

Code Pattern: Graceful Shutdown

Health Check Pattern

Common Mistakes

Trace to Layer 1

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in DevOps & Cloud

Playwright Devops

M5 Onboard

Yeet

Runbook

Incident Response

Deploy Checklist

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