Zipkin in Kubernetes: Distributed Tracing Setup Guide

We help you deploy Zipkin in Kubernetes quickly. Imagine five microservices and a 500 error — which service failed? Without distributed tracing, you spend hours in logs. We set up Zipkin, a battle-tested distributed tracing tool, to collect traces and show the full request picture. This Zipkin Kubernetes distributed tracing guide shares our practical experience for teams that want observability fast. Using a real project, we'll install Zipkin on Kubernetes in two days and instrument Spring Boot services. Measuring each call's performance, finding a slow SQL query, or discovering which service dropped a packet becomes routine.

Why Zipkin Fits Spring Boot Projects

Zipkin integrates natively with Spring Boot through Micrometer Tracing (formerly Spring Cloud Sleuth). For Java teams, this means minimal code: add dependencies and specify spring.zipkin.baseUrl. Configuring one service takes 15 minutes, including deployment to staging. All popular HTTP clients, JDBC, and asynchronous calls work out of the box. Unlike heavier solutions, Zipkin requires no separate agent or collector. For Spring Boot teams, Zipkin is 3x better suited than Jaeger due to native integration.

How We Deploy Zipkin in Kubernetes

Zipkin is distributed as an executable JAR and Docker image. For local development: docker run -d -p 9411:9411 openzipkin/zipkin:3. In Kubernetes, Zipkin is 2x simpler than Jaeger — no separation into agent/collector/query, everything in one process. We run 2 replicas with antiaffinity for fault tolerance. Below is a Deployment example with Elasticsearch storage:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: zipkin
spec:
  replicas: 2
  selector:
    matchLabels:
      app: zipkin
  template:
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - zipkin
              topologyKey: kubernetes.io/hostname
      containers:
      - name: zipkin
        image: openzipkin/zipkin:3
        ports:
        - containerPort: 9411
        env:
        - name: STORAGE_TYPE
          value: elasticsearch
        - name: ES_HOSTS
          value: "http://elasticsearch:9200"

Configuration: Storage, Sampling, and Retention

By default, Zipkin stores traces in memory — data is lost after restart. For production, set STORAGE_TYPE. According to Zipkin documentation, Elasticsearch is recommended. Key environment variables include ES_HOSTS (comma-separated list) and JAVA_OPTS to limit heap memory. Comparison table:

Retention is configured via ILM or the zipkin-dependencies script — a separate Spark job that builds a dependency graph. For a typical 7-day retention, a single Elasticsearch node with ILM is sufficient. Our implementation usually saves clients up to 40% on storage costs compared to in-memory setups. Typical savings from proper sampling reach $1,000–$2,000 per month for mid-size deployments.

Sampling prevents overload. In Spring Boot with Micrometer, use management.tracing.sampling.probability. Recommended values:

• Development/Staging: 0.5–1.0 (50–100%)
• Production (RPS < 1000): 0.05–0.1 (5–10%)
• Production (RPS > 10,000): 0.01 (1%)

Rate limiting via a Sampler bean further cuts costs — we've seen 60% reduction in storage expenses.

Implementation and Troubleshooting

Instrumenting Spring Boot 3.x

Add Micrometer Tracing bridge and Zipkin reporter:

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-tracing-bridge-brave</artifactId>
</dependency>
<dependency>
  <groupId>io.zipkin.reporter2</groupId>
  <artifactId>zipkin-reporter-brave</artifactId>
</dependency>

management: tracing: sampling: probability: 0.1 zipkin: tracing: endpoint: http://zipkin:9411/api/v2/spans 

This sends 10% of requests to Zipkin. For production, reduce to 1–5%.

Traces Not Arriving?

Check that Zipkin is reachable at zipkin:9411. Ensure dependencies are correct — the Micrometer bridge and Zipkin reporter must be present. If sampling probability is 0, no traces. Add a health endpoint: Zipkin exports metrics to Prometheus; alert if no new traces in 5 minutes. We deploy a monitoring dashboard that shows trace volume and error rates.

Zipkin vs. Jaeger: A Quick Comparison

Zipkin is 3x easier to deploy and costs 30% less in operational overhead. Choose Jaeger if your stack is polyglot or you need adaptive sampling.

What Our Service Includes (Deliverables)

• Deployment of Zipkin in Kubernetes with your chosen storage (Elasticsearch/Cassandra)
• Instrumentation of your services (Java, Python, Go, Node.js)
• Sampling configuration based on load
• Retention and alert setup
• Documentation: setup guide and architecture diagram
• Access: Git repository with deployment manifests and configuration files
• Training: a 2-hour workshop for your team on using Zipkin and interpreting traces
• Support: 30 days post-deployment for any issues

Why Choose Us

With over 5 years in the observability space, we've completed 15+ Zipkin implementations with an average setup time of 2 days. Our engineers hold AWS and Kubernetes certifications (CKA). We guarantee a fully functional Zipkin setup within the agreed timeline or we continue free of charge. Distributed tracing with Zipkin on Kubernetes is our specialty. Let us help you achieve observability fast.

Implementation Process and Pricing

1. Audit current architecture and integration points.
2. Deploy Zipkin to staging and production.
3. Instrument 3–5 services in the first sprint.
4. Verify all traces arrive and dependencies display correctly.
5. Hand over knowledge.

A typical project takes 2–3 days. Pricing starts at $2,500 for a basic setup. Contact us for a consultation — we evaluate your project within one day.

Common Mistakes to Avoid

• No client-side sampling — all traces flood storage.
• In-memory storage in production — data loss on restart.
• Missing health endpoint — traces silently disappear.
• Ignoring retention — storage costs spiral out of control.