Most AI tooling is built for the demo, not the shift. You get a working prototype, someone wants to put it in production, and suddenly you're asking: how do I validate inputs? How do I retry a flaky API? How do I deploy this without rewriting it? How do I switch models without touching every file?

AI Appliances answers all of those questions with a single framework: kdeps.

kdeps lets you define AI agents as YAML workflows — deterministic pipelines of resources (LLM calls, SQL queries, HTTP requests, Python scripts, browser automation) connected in a dependency graph. You declare what each step does and what it depends on. kdeps handles execution, validation, retries, error handling, and deployment.

This book is the complete guide to building with kdeps, from a first working agent to a multi-agent system running in production on Kubernetes.

You will learn how to:

• Build deterministic AI pipelines using a directed acyclic graph (DAG) of typed resources
• Wire LLM calls, SQL queries, HTTP clients, Python scripts, web scrapers, and browser automation into a single workflow
• Validate inputs, handle errors gracefully, and make agents resilient to real-world conditions
• Compose reusable components and build multi-agent agencies where specialized agents collaborate autonomously
• Deploy to Docker, Kubernetes, standalone binaries, or edge devices — from the same YAML, without changing a line
• Run local open-source LLMs via Ollama, or route to OpenAI, Anthropic, Gemini, Perplexity, or any compatible provider
• Debug with kdeps validate, kdeps doctor, hot-reload development mode, and trace logging
• Build native chat bots for Telegram, Discord, Slack, and WhatsApp — or process files from the command line — with the same resource DAG, just a different input source

What this book is not: a machine learning theory text, a prompt engineering tutorial, or a guide to any proprietary AI platform. It is a book about running AI in production as reliably as you run a database.

What you need: familiarity with YAML and basic command-line comfort. No prior AI/ML experience required.

Take the Course

Want to go further? The companion course turns this book into a guided learning path with chapter quizzes, a final exam and a certificate of completion: AI Appliances: The Course

Developer experience is infrastructure. The difference between a team that ships every day and a team that dreads deployments is rarely talent. More often, it is tooling. Fast feedback loops. Immutable deployments. Self-healing clusters. Observable systems. These are not luxuries reserved for large organizations—they are the foundation of reliable software delivery.

Most Kubernetes tutorials stop at kubectl apply. By now, you probably know the commands. What is often missing is the system that ties them together: a repeatable workflow that provisions a cluster in seconds, rebuilds images with the cache you expect, reloads services without dropping connections, and tells you exactly what went wrong when something fails.

This book is about building that system.

Kubernetes for All teaches Kubernetes from the ground up by having you build a complete cloud-native platform yourself. Instead of deploying to a managed cluster and accepting the magic, you'll create your own datacenter from scratch using a single Bash script that provisions a full multi-node Kubernetes environment.

Along the way, you'll discover not just how Kubernetes works, but why it works the way it does. You'll build the cluster, deploy applications, automate operations, implement GitOps workflows, add observability with Prometheus and Grafana, and follow requests through distributed systems with OpenTelemetry. Every layer is introduced by building it yourself.

No prior Kubernetes experience is required.

You'll work with Kind, Helm, Pods, Deployments, Services, Ingress, ConfigMaps, Secrets, Persistent Volumes, StatefulSets, and the Kubernetes API. Every command is explained. Every concept is demonstrated. By the end, you'll have a production-style environment running real microservices—and the understanding needed to operate it with confidence.

This is a book about cloud-native engineering in practice.

Not slides. Not architecture diagrams disconnected from reality. Not vendor marketing.

Bash. Docker. Helm. Kind.

Real tools solving real problems, guided by five principles that appear throughout the book:

• Infrastructure as Code
• Immutable Deployments
• Fast Feedback
• Fail Loudly and Self-Heal
• Observability

What You Will Build

At the heart of the book is datacenter.sh, a single script that provisions and operates an entire Kubernetes environment.

By the time you're finished, that script will deploy 16 microservices, PostgreSQL, Kafka running in KRaft mode, and a web frontend. Whether the target is a local Kind cluster or a bare-metal datacenter, the deployment path remains the same. The infrastructure changes. The workflow does not.

You write every line.

You understand every decision.

You own the result.

Who This Book Is For

This book is for engineers who want Kubernetes tooling they can understand, modify, and trust.

You deploy applications. You write scripts. You value systems that are version-controlled, observable, reproducible, and fast.

You want your inner development loop—change code, build, deploy, verify—to take seconds instead of minutes.

Most of all, you want to understand what is happening beneath the abstractions.

No certification is required.

Just Docker, Kind, a terminal, and the desire to build something real.

Take the Course

Want to go further? The companion course turns this book into a guided learning path with chapter quizzes, a final exam and a certificate of completion: Kubernetes for All: The Course