book

Agentic DevOps with Claude Code

Name: Agentic DevOps with Claude Code
Author: Michael Rishi Forrester
ISBN: 9781808344190

by Michael Rishi Forrester

September 2026

Intermediate

322 pages

7h 22m

English

Packt Publishing

Read now

Unlock full access

Preface
Free benefits with your book
Part 1: Building a Controlled Cloud-Native Foundation
Chapter 1: Designing an AI-Native Internal Developer Platform
Defining the AI-native platform outcomeFrom components to capabilitiesA practical outcome statementWhy this matters to operationsDefining done before selecting toolsHands-on exercise: write the platform outcome contractTroubleshooting the outcome definitionMapping the foundation, AI, and self-service planesThe cloud-native foundationWhat happens when the foundation failsThe AI planeWhat happens when the AI plane failsThe self-service planePlatform-owned defaults versus developer choicesDependency mapping exerciseTroubleshooting the plane modelSeparating the builder agent from the served modelThe builder agentThe runtime modelThe runtime agentComparing the rolesA request path exampleHands-on exercise: create the identity matrixTroubleshooting identity designDrawing trust boundaries and production boundariesReasoning-layer controlsInfrastructure-layer controlsClassifying the workshop decisionsThreat-model exerciseTroubleshooting the trust modelProduction readiness checklistSummary
Chapter 2: Governing Claude Code with Specifications, Tests, and Permissions
Establishing ground truth with a no-change preflightWhat bare meansThe preflight evidence setUsing an explicit kubeconfigHands-on lab: build the Phase 0 gatePrerequisitesFiles usedStep 1: Read tests/test_phase_0_preflight.pyStep 2: Run the testTroubleshooting tipsWriting phased build specifications and completion gatesWhy one giant prompt failsAnatomy of a phase specificationWriting a testable goalFixing decisions before executionThe stop conditionHands-on lab: write a phase contractCreate spec/phases/example-inventory.mdRun a specification reviewTroubleshooting specification problemsPinning versions and controlling source provenanceWhy chart and application versions both matterValidating components.yamlRun the component validatorApproved sources and vendoringSource provenance checklistWhen a newer version is worseHands-on lab: make an unpinned component fail CITroubleshooting tipsConstraining Claude Code with permissions and audit hooksAllow, ask, and denyThe defense layersAudit hooksProtecting the audit trailHands-on lab: test the permission boundary1.Set the audit identity2.Run three requestsExpected behavior3.Inspect the audit recordWhat just happenedTroubleshooting tipsRunning the test-build-commit-stop control loopObserveProve the expected failureBuild through GitValidate live behaviorReview the diffCommit and checkpointStop and approveHands-on lab: execute a controlled dry run1.Run the failing test2.Build and validateWhat just happenedTroubleshooting the control loopProduction reality checkSummary
Chapter 3: Bootstrapping the GitOps Foundation
Bootstrapping Argo CD and defining the GitOps exceptionThe bootstrap boundaryWhy server-side apply is requiredArgo CD 3.x considerationsUsing in-cluster GiteaHands-on lab: bootstrap Argo CDPrerequisitesFiles usedRender the pinned chartApply the bootstrapApply the root ApplicationExpected outputTroubleshooting tipsStructuring the App-of-Apps and sync-wave orderReading the root ApplicationWhy sync waves existAnnotating a child ApplicationHealth and synchronization are differentApp-of-Apps refresh behaviorHands-on exercise: inspect the dependency graphExpected outputTroubleshooting tipsManaging certificates, secrets, storage, and workload identitycert-manager as an early dependencyThe secret flowThe workshop OpenBao configurationProduction OpenBao designgp3 storageEKS Pod IdentityHands-on lab: prove secret materialization and storage readiness1.Run the Phase 1 tests2.Inspect without disclosing the secretTroubleshooting tipsIntroducing platform policy in audit modeWhy audit firstBaseline policiesController default driftPolicy review workflowProduction reality checkHands-on exercise: inspect audit results1.List policy reports2.Inspect one resultTroubleshooting tipsRepairing Git-sourced faults at the sourceThe diagnostic ladder1.Inspect Argo CD first2.Fix one source field3.Refresh the cascadeExpected outputRecurring fault classesTroubleshooting tipsProduction reality checkSummary
Chapter 4: Building the Platform Observability Plane
Designing a shared telemetry pipelineOpenTelemetry as the seamSignal contractsCollector rolesProcessing orderResource identity and cardinality budgetsWhy this matters operationallyHands-on exercise: define the telemetry contractExpected resultTroubleshooting the designCollecting metrics, logs, and traces on EKSMetrics collectionLog collectionTrace collectionCollector deployment detailsThe OpenTelemetry OperatorHands-on lab: verify collectors and scrape targetsPrerequisitesFiles usedCheck the daemonsetInspect Prometheus targetsTroubleshooting tipsPersisting and querying telemetry with the observability stackPrometheus and Alertmanager persistenceGrafana data sourcesQuerying by APILoki label disciplineTempo search and trace identityHands-on lab: query Grafana data sourcesRetrieve the password safelyQuery through a port-forwardTroubleshooting tipsValidating the telemetry path and controlling driftThe probe trace1.Create a compact trace probe2.Run the phase test3.Diagnosing a missing traceController-default driftProduction reality checkTroubleshooting tipsSummary
Chapter 5: Delivering the Developer Portal and Platform Extensions
Treating Backstage as the platform interfaceInterface versus mechanismWhat a developer should seeWhat the platform team should ownWhy Backstage arrives lastThe pre-built imageBackstage data in the corrected workshop buildHands-on exercise: review the portal contractExpected resultTroubleshooting the interface boundaryConnecting the catalog, TechDocs, and live Argo CD stateRegistering a componentTechDocs as docs-as-codeThe Argo CD integrationQuerying the catalog APIExpected outputQuerying the Argo CD proxyCredential boundariesCatalog eventual consistencyHands-on lab: verify catalog and live delivery statePrerequisitesFiles usedRun the Phase 3 integration testsTroubleshooting tipsAdding workflows, events, progressive delivery, and autoscalingArgo WorkflowsArgo EventsArgo RolloutsKEDAHands-on lab: verify extension APIs1.Check the CRDs2.Run the full phase gateTroubleshooting tipsDiagnosing portal image, configuration, and credential failuresThe diagnostic layersFailure 1: doubled registry pathFailure 2: the file exists but the process cannot reach itFailure 3: production configuration never loadedFailure 4: secret and credential driftFailure 5: database secret and storage assumptionsFailure 6: eventually consistent catalog stateHands-on lab: diagnose a failed Backstage deployment1.Inspect Argo CD and the rendered workload2.Inspect events and logsExpected evidence3.Test the outcome after the repairTroubleshooting checklistProduction reality checkSummary
Part 2: Adding the AI Plane
Chapter 6: Creating a Governed Gateway for Agent Traffic
Using Gateway API as the platform traffic contractThe three-object contractWhy status conditions matterHands-on lab: establish the gateway contract1.Create gateway.yaml2.Create application.yaml3.Create test_gateway_contract.py4.Run the labWhat just happenedTroubleshooting tipsSeparating kgateway and agentgateway responsibilitiesThe practical divisionInstall order and ownershipInspect the pinned ApplicationsExpected outputThe OCI detail that bitesThe chart-values correctionExpected resultWhat this command is doingTroubleshooting controller overlapProduction reality checkMediating LLM, MCP, and agent-to-agent trafficThree traffic types, three risk shapesLab: route the local vLLM service1.Create vllm-backend.yaml2.Create vllm-route.yaml3.Verify route attachmentThe MCP pathThe A2A pathTest the mediated path from the agent namespaceExpected resultWhat this command is doingProduction reality checkLanding AI policies in audit modeAudit first does not mean audit foreverReview the guardrail-reference policyTest an audited violationApply and inspect the fixtureExpected outputWhat just happenedThe registry policy caveatThe OTel annotation caveatThe bypass-policy caveatTroubleshooting policy driftVerifying routes, mTLS, and audit loggingBuild an evidence chainAdd a mutual-TLS listenerTest both sides of mTLSExpected behaviorWhat just happenedVerify route parents programmaticallyDefine the audit record1.Create tests/check_audit_shape.py2.Run the audit checkExpected outputWhat just happenedTroubleshooting the complete pathProduction reality checkSummary
Chapter 7: Running Agents as Kubernetes Resources
Declaring and reconciling agents with kagent CRDsAn Agent is a resource, not a personalityCRDs before controllersExpected outputWhat this command is doingHands-on lab: declare the platform helper1.Create agent.yaml2.Inspect the resource before commit3.Create test_agent_ready.py4.Run the reconciliation testTroubleshooting tipsProduction reality checkRouting a ModelConfig to an in-cluster endpointOpenAI-compatible describes a protocolCreate the placeholder key1.Create modelconfig.yaml2.Check the endpoint from the agent namespaceUse a deterministic inference probe1.Run the probeTroubleshooting the ModelConfigConnecting MCP tools through agentgatewayMCP resources in the pinned stackRepository truth before extensionCreate remote-mcp.yamlBind named tools to the Agent1.Inspect discovered tool status2.Create test_mcp_contract.pyTest one tool callExpected outputTroubleshooting MCPProduction reality checkBlocking prompt injection with LLM GuardLLM Guard in this platformThe runtime integration gapCreate llm-guard-policy.yamlCreate the deterministic fixture1.Run the paired test2.Inspect the audit decisionTroubleshooting guardrailsProduction reality checkInstrumenting agent calls with OpenLLMetryTrace the useful boundariesCreate trace_probe.pyPin the dependenciesSet the semantic conventionExpected outputWhat just happenedQuery Tempo for GenAI evidenceExpected outputWhat this command is doingCreate a polling testWhat this code is doingTroubleshooting telemetryProduction reality checkSummary

Chapter 8: Serving and Observing Models on Kubernetes
Deploying KServe and an OpenAI-compatible vLLM endpointThe serving topologyInstall APIs before resourcesExpected outputWhat this command is doingHands-on lab: create the predictor1.Create base/inferenceservice.yaml2.Create overlays/cpu/resources.yaml3.Create overlays/cpu/runtime.yaml4.Create base/kustomization.yamlCreate the KustomizationRender before reconciliationExpected resultWhat just happenedHandle KServe's annotation normalizationProduction reality checkTuning CPU inference for Kubernetes constraintsThe live failure mapMeasure instead of guessingExpected evidenceWhat these commands are doingWatch model startupExpected milestonesWhat this command is doingInspect shared memoryExpected outputNUMA policy and securityTune context length deliberatelyTroubleshooting CPU performanceRunning and tracing an end-to-end inferenceStart with the cheapest requestExpected outputWhat this command is doingCreate inference_probe.pyRun the probe twiceExpected outputWhat just happenedTrace model and token attributesExpected evidenceWhat this command is doingValidate tool-calling supportExpected behaviorTroubleshooting the round tripProduction reality checkPositioning llm-d, GPUs, and managed model routesThe serving decisionMoving to GPUPositioning llm-dManaged model routesRoute by policy, not model fashionProduction reality checkTesting readiness, performance, and regression-sensitive settingsTest at four layersThe readiness complicationCreate test_phase_6_serving.pyAdd volume and memory assertionsTest the API model nameCreate benchmark_inference.pyExpected outputSet a generous regression gateCustomize Argo CD health carefullyRun the phase gateExpected resultTroubleshooting regression testsProduction reality checkCapture a phase evidence recordExpected resultWhat just happenedSummary
Part 3: Productizing and Operating the Platform
Chapter 9: Shipping a Governed Self-Service Golden Path
Defining the agent-service template contractThe contract before the YAMLDesigning inputs that fail earlyDefine the generated repository as an APIAcceptance criteria for the contractGenerating governed manifests from a Backstage formLab goal and prerequisitesVerify the scaffolder action inventoryExpected outputCreate template.yamlGenerate a bounded Agent resourceRender the approved tools explicitlyCorrect the route ownership boundaryDry-run the render before publishingTroubleshooting template generationProduction reality checkDiscovering repositories with an Argo CD ApplicationSetThe discovery pathConstrain the Argo CD project firstCreate applicationset.yamlTest discovery without accepting any repositoryObserve the generated ApplicationExpected outputTroubleshooting ApplicationSet discoveryDeletion and retirementRunning and verifying the form-to-trace golden pathThe evidence chainLab files and test dataSubmit the formExpected scaffolder outputExpected outputWhat just happenedPoll for reconciliationVerify Agent generation and route conditionsExpected outputInvoke the safe pathExpected resultVerify the first traceCheck policy evidenceExpected outputMeasure the right durationTroubleshooting the complete pathExtension challengeProduction reality checkSummary
Chapter 10: Enforcing Governance and Taking the Platform to Production
Promoting AI policies from audit to enforceTwo control layersChoose a promotion candidateInspect policy reportsWhat this command is doingWrite the policy for per-rule enforcementCreate denied and admitted fixturesPromote through Git, not a live patchExpected outputWhat this command is doingProve denial without creating the resourceExpected outputWhat this command is doingExpected outputWhat this command is doingTest updates as well as createsMonitor the policy after promotionProduction reality checkAttributing agent and human actions in LokiDefine the audit event contractEmit one structured eventQuery one agent's activityExpected outputFind malformed audit recordsFind unattributed actionsStrengthen the automated Loki testDistinguish actor, agent, and platform identitiesProtect the evidence pathConverting live defects into tests and recovery patternsFrom incident to contractClassify the workshop defectsTest rendered configuration, not source fragmentsProve application configuration is activeGuard image provenance and runtime behaviorHandle controller-owned drift preciselyReplace sleeps with condition pollingWrite recovery patterns, not command collectionsTest the external surfaceArchive the defect recordReplacing workshop shortcuts with production controlsThe production boundaryIdentity before convenienceSecrets and key managementData and persistenceNetwork and capability boundariesModel serving and costSupply-chain controlsCompare workshop and production controlsMulti-cluster operationsAvailability and recoveryHuman-in-the-loop controlsPlanning an incremental adoption roadmapStart with one operational problemThe 30-day planWeek 1: inventory and control baselineWeek 2: read-only observation pathWeek 3: governed delivery pilotWeek 4: enforce one rule and review production gapsUse maturity gates, not calendar optimismAssign ownership that survives the launchReport outcomes without AI theatreYour first production commitmentSummary
Chapter 11: Unlock the Code Bundle and the PDF Version
Unlock this book's free benefits in three easy steps
Other Books You May Enjoy
Index

Content preview from Agentic DevOps with Claude Code

Part 1 Building a Controlled Cloud-Native Foundation

The first part of this book establishes the controlled cloud-native foundation on which the rest of the platform depends. We begin with the architecture because a 30-component platform becomes unmanageable quickly if every tool is treated as an isolated installation. The goal is to define the platform planes, ownership boundaries, trust paths, and evidence we will use to decide whether the system is healthy.

From there, we govern Claude Code with a written specification, narrow permissions, and tests; bootstrap Argo CD and the GitOps dependency chain; build metrics, logs, and traces into the platform; and deliver Backstage as the developer-facing entry point. By the end of this part, you will ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781808344190

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Agentic DevOps with Claude Code

by Michael Rishi Forrester

Part 1

Building a Controlled Cloud-Native Foundation

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.