Sidecar pattern
The sidecar pattern deploys an auxiliary component alongside a primary application or service to provide supporting functionality independently of its core code.
Effective Platform Engineering
A sidecar proxy is a proxy deployed alongside an application workload to handle communication without requiring application-code changes.
- How it is used
- Moves service-communication behavior into a proxy alongside the workload, avoiding application-code changes.
- How deep it goes
- Defines proxy behavior and compares per-pod with shared placement, but does not show individual proxy configuration.
- Examples
- Uses web-token validation, connection retries, and encryption between proxies as configuration examples.
- What you can do after
- Operate/configure it through a service mesh to apply communication behavior without changing application code.
Read how Effective Platform Engineering explains sidecar pattern →
Google Anthos in Action
A sidecar is a container deployed alongside a main container in the same Pod to provide supporting functionality such as proxying.
- How it is used
- Adds logging, monitoring, backups, or service-mesh traffic handling alongside a Kubernetes workload without changing its application logic.
- How deep it goes
- Defines the pattern, explains proxy responsibilities, and gives injection and verification steps; does not show a complete sidecar manifest.
- Examples
- Uses logging and backup sidecars, a web-server/database scaling contrast, and namespace-labeling and Pod-readiness commands.
- What you can do after
- Operate/configure it by enabling Anthos Service Mesh injection, restarting workloads, and checking that Pods contain both containers.
Logs and Telemetry
The sidecar pattern deploys a supporting process alongside a primary application component so they share a lifecycle and execution context.
- How it is used
- Collects application-specific observability events locally in a Pod before routing them to centralized backends.
- How deep it goes
- Explains Kubernetes deployment, shared files, localhost delivery, DaemonSet trade-offs, context injection, and forwarding startup behavior.
- Examples
- Demonstrates a two-container Pod that tails two shared log files and writes combined output.
- What you can do after
- Operate/configure it to collect application logs through shared storage or local endpoints and route them onward.
Kubernetes in Action, Second Edition
The sidecar pattern places a complementary process in a separate container alongside a primary application process in the same pod.
- How it is used
- Extends a primary application through a complementary container in the same pod, without changing application code.
- How deep it goes
- Works through proxy testing and container logs, then explains native-sidecar startup, restart, and shutdown; does not detail proxy internals.
- Examples
- Uses an Envoy HTTPS proxy, curl and log checks, and a traffic-meter native-sidecar manifest.
- What you can do after
- Build it from scratch with a Pod manifest, then operate it using kubectl port-forward and container-specific logs.
Read how Kubernetes in Action, Second Edition explains sidecar pattern →
Authorization in Action
A sidecar is a separately deployed component or proxy that runs alongside a primary service to provide supporting functionality.
- How it is used
- Uses sidecars as local policy enforcement points for internal service-to-service authorization.
- How deep it goes
- Explains the identity, request-context, decision, and forwarding flow through a worked example without detailing mesh deployment.
- Examples
- Illustrates document indexing with a Cedar policy that denies documents classified as Legal.
- What you can do after
- Evaluate where sidecar enforcement complements gateways and per-service proxies across an API ecosystem.
Grokking Software Architecture
The sidecar pattern deploys a helper process alongside a primary application process to provide supporting infrastructure capabilities.
- How it is used
- Keeps cross-cutting network security and traffic handling out of application code by deploying a helper proxy alongside each service.
- How deep it goes
- Defines the pattern and outlines staging and legacy-migration procedures, without detailing proxy implementation.
- Examples
- Uses service-mesh proxies for polyglot microservices and an audit-first rollout for legacy traffic.
- What you can do after
- Operate/configure a gradual service-mesh rollout, validating routing and mTLS in staging before enforcing policies on legacy services.
Read how Grokking Software Architecture explains sidecar pattern →
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
A sidecar container is an additional co-located container that supports or monitors a primary container or its execution environment.
- How it is used
- Supports or monitors a primary application by running alongside it in a tightly coupled Podman pod.
- How deep it goes
- Explains shared namespaces, cgroups, volumes, and a complete Podman creation and startup workflow.
- Examples
- Demonstrates a ubi8 sidecar rewriting shared HTML while a myapp web server serves the resulting timestamps.
- What you can do after
- Apply it via Podman CLI to create, populate, start, and inspect a pod containing a primary container and sidecar.
Acing the Certified Kubernetes Administrator Exam, Second Edition
The sidecar pattern runs a supporting process alongside a primary application process, typically within the same pod.
- How it is used
- Supports log collection and other close-coupled assistance for a primary application within one pod.
- How deep it goes
- Explains shared namespaces, shared volumes, manifest changes, and kubectl verification, but does not detail broader sidecar architectures.
- Examples
- Uses a busybox log sidecar, an emptyDir volume, Pod YAML, and kubectl logs output showing individual or combined container logs.
- What you can do after
- Apply it via kubectl by creating a two-container Pod, sharing storage, and inspecting each container's logs.
Designing Deep Learning Systems: A guide for software engineers
A container deployed alongside a primary application container to provide supporting functionality such as adaptation, proxying, or initialization.
- How it is used
- Deploys alongside model servers to adapt requests, prepare models, and preserve an existing prediction API.
- How deep it goes
- Explains container responsibilities, shared storage, request flow, model registration, and scaling, but does not provide deployment configuration.
- Examples
- Uses TorchServe and Triton pods with proxy containers that download, register, and serve models from shared repositories.
- What you can do after
- Operate/configure an adapter-proxy container that integrates a model server without changing public inference interfaces or external model storage.
Read how Designing Deep Learning Systems: A guide for software engineers explains sidecar pattern →
Secure APIs
A sidecar is a container-application pattern in which a secondary process runs alongside a primary application to provide supporting functionality.
- How it is used
- Uses a neighboring process to collect logs and provide supporting functionality for containerized applications.
- How deep it goes
- Defines the pattern and explains its logging flow, but does not detail sidecar implementation or orchestration configuration.
- Examples
- Illustrates a log collector agent running beside an application container and forwarding standard-output streams for analysis.
- What you can do after
- Operate/configure a container logging arrangement that collects application output beside the primary service.
Kafka for Architects
The sidecar pattern deploys an auxiliary component alongside a primary service component to provide supporting functionality without embedding it in the service.
- How it is used
- Separates service business logic from reusable cross-cutting communication and infrastructure concerns.
- How deep it goes
- Explains containers, proxy traffic flow, responsibilities, reuse, and centralized configuration without covering implementation details.
- Examples
- Uses a two-container microservice and service-mesh traffic routed through a sidecar proxy.
- What you can do after
- Operate/configure sidecar responsibilities through a service-mesh control plane.
LLMs in Production
A sidecar is a companion component deployed alongside a primary application to perform supporting processing or communication.
- How it is used
- Moves LLM monitoring and log processing out of the inference path to protect production latency.
- How deep it goes
- Explains the same-pod logging pattern and its latency rationale, but does not detail alternative sidecar configurations.
- Examples
- Uses whylogs, LangKit, fluentd, WhyLabs, and Prometheus in a Kubernetes logging arrangement.
- What you can do after
- Operate/configure parallel monitoring for an LLM service using a Kubernetes sidecar and logging tools.
Also covered in
- Software Security for Developers
- Platform Engineering on Kubernetes
- Architecture Modernization: Socio-technical alignment of software, strategy, and structure
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- API gatewayAn API gateway is a server-side intermediary that provides an entry point for client requests to backend APIs or services and routes or mediates those requests.
- service meshA service mesh is an infrastructure layer that manages communication between distributed services and commonly provides traffic control, security, and observability.
Related concepts
- service meshused by · A service mesh is an infrastructure layer that manages communication between distributed services and commonly provides traffic control, security, and observability.
- containerkind of · A software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- poduses · A Kubernetes Pod is the smallest deployable unit in Kubernetes, grouping one or more co-located containers that share networking and other resources.
- automatic sidecar injectionproduced by · Automatic sidecar injection is the admission-time addition of a proxy sidecar to newly created pods based on cluster configuration.
- DaemonSetcontrasts with · A DaemonSet is a Kubernetes workload resource that ensures a Pod runs on each eligible node or selected nodes matching specified criteria.
- data contractconfigured by · A data contract is an agreement specifying the structure, meaning, and expectations for data exchanged between producers and consumers.
Questions about sidecar pattern
What is sidecar pattern?
The sidecar pattern deploys an auxiliary component alongside a primary application or service to provide supporting functionality independently of its core code.
Which Manning books explain sidecar pattern?
Effective Platform Engineering, Google Anthos in Action, Logs and Telemetry, Kubernetes in Action, Second Edition, Authorization in Action, Grokking Software Architecture, Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more, Acing the Certified Kubernetes Administrator Exam, Second Edition and 4 more.
What should I know before learning sidecar pattern?
Manning books that teach sidecar pattern usually introduce container, microservice architecture, API gateway and service mesh first.
What is the difference between sidecar pattern and DaemonSet?
The sidecar pattern deploys an auxiliary component alongside a primary application or service to provide supporting functionality independently of its core code. A DaemonSet is a Kubernetes workload resource that ensures a Pod runs on each eligible node or selected nodes matching specified criteria.
What is sidecar pattern a kind of?
Sidecar pattern is a kind of container. A software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.











