Forrester | Agentic DevOps with Claude Code | E-Book | www.sack.de
E-Book

E-Book, Englisch, 322 Seiten

Reihe: Packt Publishing

Forrester Agentic DevOps with Claude Code

Build governed AI platforms on Kubernetes with GitOps, observability, and self-service workflows
1. Auflage 2026
ISBN: 978-1-80834-418-3
Verlag: Packt Publishing
Format: EPUB
Kopierschutz: 0 - No protection

Build governed AI platforms on Kubernetes with GitOps, observability, and self-service workflows

E-Book, Englisch, 322 Seiten

Reihe: Packt Publishing

ISBN: 978-1-80834-418-3
Verlag: Packt Publishing
Format: EPUB
Kopierschutz: 0 - No protection



Build agentic DevOps workflows without bypassing the controls your Kubernetes platform already depends on. This book shows you how to use Claude as a controlled platform-engineering worker while introducing agents, model serving, and developer self-service through reproducible GitOps workflows, explicit trust boundaries, policy checks, and testable completion gates.

You'll establish a cloud-native foundation with Argo CD, cert-manager, OpenBao, External Secrets Operator, Kyverno, Prometheus, Grafana, Loki, Tempo, and OpenTelemetry. You'll then add governed AI traffic using Gateway API, kgateway, agentgateway, kagent, MCP tools, and LLM Guard before serving an OpenAI-compatible model with KServe and vLLM.

The hands-on approach shows you how to constrain Claude with specifications, permissions, audit hooks, tests, and Git checkpoints. You'll trace agent and model activity, diagnose failures from evidence, and turn operational fixes into reusable tests. You'll also build a Backstage template and Argo CD ApplicationSet that provide a governed path from developer request to running agent.

By the end of the book, you'll be able to build and validate an AI-native internal developer platform in phases, route agent and model activity through existing platform controls, and prepare the architecture for production use.

Forrester Agentic DevOps with Claude Code jetzt bestellen!

Autoren/Hrsg.


Weitere Infos & Material


Preface


Most platform teams are no longer being asked whether AI belongs in the engineering workflow. They are being asked when it will arrive, where it will run, what it will be allowed to touch, and who will answer when it makes a poor decision. Those are not model questions. They are platform-engineering questions: identity, policy, delivery, observability, ownership, and recovery. A useful agent must fit inside those controls. Otherwise, it is just a fast new way to create an incident.

This book grew out of a live build in which Claude Code helped assemble a 33-component AI-native internal developer platform on a real Kubernetes cluster. The agent scaffolded configuration, wired GitOps applications, created Backstage templates, declared agents, and helped troubleshoot sync failures. That sounds impressive, but speed was never the main lesson. The important part was that the agent worked from a specification, operated within defined permissions, produced changes in Git, and had to pass the same validation we would expect from any other contributor.

The platform follows a simple idea: AI should extend the cloud-native systems you already trust, not sit beside them as an ungoverned bolt-on. We begin with Argo CD, secrets management, policy enforcement, observability, and Backstage. We then add gateways for agent and model traffic, kagent resources, MCP tools, KServe and vLLM for model serving, prompt protection, and end-to-end telemetry. Finally, we package the result as a self-service golden path that developers can use without bypassing the controls the platform team needs.

Each chapter is part of one continuous build. You will inspect architecture before installation, define trust boundaries before permissions, and validate one layer before the next. The examples use real manifests, commands, tests, and failures. The goal is not to memorize 33 product names. It is to learn the patterns that survive product changes: Git as the source of truth, narrow interfaces, structured inputs and outputs, policy before action, end-to-end telemetry, and human authority over consequential changes.

Here is the part people usually skip: a successful demo proves little about production readiness. Clusters drift. Charts change. CRDs appear before controllers are ready. Credentials leak into logs. Policies block the right thing for the wrong reason. Agents can return confident nonsense, call the wrong tool, or repeat a failing action until a timeout becomes an outage. The live build encountered real defects, and this book treats them as engineering evidence. We verify behavior, turn failures into tests and runbooks, and make boundaries visible. Read-only first. Always.

This is not about replacing platform engineers. An agent can summarize, scaffold, correlate, and help with triage; it cannot own the risk. By the end, you will have a reference architecture and a working path from cluster bootstrap to governed agent service, plus the checks needed to decide whether it deserves wider access. The goal is not magic. The goal is a better operational workflow: fast when safe, cautious when the blast radius is real, and observable enough for the next engineer to understand what happened. We begin by defining trust boundaries before installing the first component.

Who this book is for


This book is for platform engineers, DevOps engineers, SREs, cloud engineers, architects, tech leads, and engineering leaders building or evaluating Kubernetes-based internal developer platforms. It is for practitioners who will be responsible when the platform fails, not only people experimenting in a sandbox. You should understand Kubernetes and basic Git, Helm, and GitOps workflows. No prior experience with Backstage, kagent, MCP, KServe, or model serving is required; each appears when it enters the build.

What this book covers


The book follows one continuous build: establish a controlled platform, add the AI plane, and then turn the result into a governed product that teams can use and operators can support. Once the cloud-native foundation is in place, the focus shifts to adding governed agent traffic, agent and model runtimes, self-service delivery, and the controls required for production operation. The chapter roadmap below shows where each step fits:

, , maps platform planes, trust boundaries, ownership, and component roles before anything is installed.

, , shows how specifications, narrow permissions, tests, and Git keep an AI coding agent under operational control.

, , uses a small Argo CD bootstrap, App-of-Apps, and sync waves to create a reproducible, reviewable foundation.

, , connects metrics, logs, traces, and dashboards so the complete telemetry path is visible and testable before agents arrive.

, , turns Backstage into a practical front door for the catalog, documentation, GitOps state, and operational workflows.

, , uses Kubernetes Gateway API as the traffic contract for the AI plane, separates the roles of kgateway and agentgateway, and lands four Kyverno policies in Audit mode so violations can be measured before workloads are blocked.

, , declares agents, models, and MCP tools as Kubernetes resources, then adds prompt-injection protection and tracing before operational use.

, , takes model serving from YAML to verified inference with KServe and vLLM while measuring resource use, latency, and telemetry.

, , builds a Backstage golden path that creates a repository, deploys governed manifests through GitOps, and proves the result with telemetry.

, , moves the platform from demo to service by enforcing policy, attributing actions, turning defects into tests, and planning production adoption

To get the most out of this book


You will get the most value by working through the chapters in order and running the labs against a non-production Kubernetes cluster. Have a modern browser, Git access, a Claude Code subscription, and working kubectl and Helm access to the cluster. Familiarity with Argo CD or Flux is helpful, but not required.

Clone the book repository and use its current manifests as the technical source of truth, because chart versions and APIs will change. Work in a branch, read every diff, and run the validation checks before moving on. Keep credentials out of the repository, use least-privilege access, and do not point the labs at production. Read-only first is not a slogan here; it is how we keep learning from becoming an incident.

Download the example code files


The code bundle for the book is hosted on GitHub at https://github.com/PacktPublishing/Agentic-DevOps-with-Claude-Code. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing. Check them out!

Download the color images


We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here:https://packt.link/gbp/9781808344190

Conventions used


There are a number of text conventions used throughout this book.

: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. For example: " still needs implementation through repository controls"

A block of code is set as follows:

Any command-line input or output is written as follows:

Bold: Indicates a new term, an important word, or words that you see on the screen. For instance, words in menus or dialog boxes appear in the text like this. For example: "The phrase AI-native platform can mean almost anything if we let it. "

Warnings or important notes appear like this.

Tips and tricks appear like this.

Get in touch


Feedback from our readers is always welcome.

General feedback: If you...



Ihre Fragen, Wünsche oder Anmerkungen
Vorname*
Nachname*
Ihre E-Mail-Adresse*
Kundennr.
Ihre Nachricht*
Lediglich mit * gekennzeichnete Felder sind Pflichtfelder.
Wenn Sie die im Kontaktformular eingegebenen Daten durch Klick auf den nachfolgenden Button übersenden, erklären Sie sich damit einverstanden, dass wir Ihr Angaben für die Beantwortung Ihrer Anfrage verwenden. Selbstverständlich werden Ihre Daten vertraulich behandelt und nicht an Dritte weitergegeben. Sie können der Verwendung Ihrer Daten jederzeit widersprechen. Das Datenhandling bei Sack Fachmedien erklären wir Ihnen in unserer Datenschutzerklärung.