Service Mesh v roce 2026 — Istio, Cilium a budoucnost síťové vrstvy

Kubernetes vyřešil orchestraci kontejnerů. Ale síťová komunikace mezi mikroslužbami — pozorování, zabezpečení a řízení provozu — zůstávala dlouho problémem. Service mesh tento problém řeší. V roce 2026 se landscape dramaticky změnil: eBPF nahrazuje sidecar proxy, Ambient mode v Istio mění pravidla hry a Cilium se stal de facto standardem pro cloud-native networking. Jak se v tom vyznat?

Co je service mesh a proč ho potřebujete¶

Service mesh je infrastrukturní vrstva, která řídí síťovou komunikaci mezi mikroslužbami. Místo toho, aby každá služba implementovala vlastní logiku pro retry, circuit breaking, mTLS nebo load balancing, tyto funkce přesouvá do síťové vrstvy.

Představte si to jako highway system pro vaše mikroslužby. Bez service mesh má každá služba vlastní GPS navigaci, vlastní pravidla přednosti a vlastní bezpečnostní systém. Service mesh vytvoří jednotnou dopravní infrastrukturu s pravidly, monitoringem a řízením provozu.

Kdy service mesh skutečně potřebujete¶

Ne každý cluster potřebuje service mesh. Pokud máte 5 služeb a jeden tým, overhead se nevyplatí. Service mesh začíná dávat smysl, když:

• Máte 20+ mikroslužeb s komplexními komunikačními vzory
• Více týmů sdílí cluster a potřebují izolaci provozu
• Regulatorní požadavky vyžadují mTLS everywhere a audit trail
• Zero trust security je architektonický požadavek
• Canary deployments a traffic splitting jsou součástí release procesu
• Observability na úrovni L7 (HTTP/gRPC) je nutná bez instrumentace kódu

Co service mesh řeší¶

Architektura: Sidecar vs Sidecarless¶

Historicky všechny service mesh implementace používaly sidecar pattern — ke každému podu se připojí proxy kontejner (typicky Envoy), který interceptuje veškerý síťový provoz.

Sidecar model (klasický)¶

┌─────────────────────────┐
│ Pod                     │
│ ┌─────────┐ ┌─────────┐│
│ │  App    │↔│ Envoy   ││
│ │Container│ │ Sidecar ││
│ └─────────┘ └─────────┘│
└─────────────────────────┘

Výhody: - Plná L7 funkcionalita (HTTP headers, gRPC metadata) - Izolace — kompromitace proxy neovlivní ostatní pody - Mature, battle-tested (Istio od 2017)

Nevýhody: - Resource overhead — každý pod spotřebuje 50–100 MB RAM a 0.1–0.5 vCPU navíc - Latence — dvě extra TCP connections per request (~1–3 ms) - Startup delay — init container + sidecar injection zpomaluje cold start - Upgrade complexity — rolling restart všech podů při upgradu proxy

Sidecarless model (eBPF-based)¶

┌─────────────────────────┐
│ Node (kernel)           │
│ ┌─────────────────────┐ │
│ │ eBPF programs       │ │
│ │ (L3/L4 processing)  │ │
│ └─────────────────────┘ │
│ ┌───────┐ ┌───────┐    │
│ │ Pod A │ │ Pod B │    │
│ │ (app) │ │ (app) │    │
│ └───────┘ └───────┘    │
└─────────────────────────┘

Výhody: - Minimální overhead — eBPF programy běží v kernelu, žádný extra kontejner - Nižší latence — zpracování na úrovni kernelu, bez user-space proxy - Jednodušší upgrade — update DaemonSet místo restart všech podů - Nižší spotřeba — 10–30 % méně CPU a RAM oproti sidecar modelu

Nevýhody: - Omezená L7 funkcionalita v čistém eBPF (potřeba per-node proxy pro L7) - Kernel verze dependency (Linux 5.10+, ideálně 6.1+) - Menší izolace — shared per-node komponenta

Hybrid: Istio Ambient Mode¶

Istio v roce 2024 představilo Ambient mode jako alternativu k sidecar injekci. V roce 2026 je Ambient mode GA a stává se doporučeným modelem nasazení.

Ambient mode používá dvouvrstvou architekturu:

1. ztunnel (zero-trust tunnel) — per-node DaemonSet pro L4 (mTLS, TCP routing)
2. waypoint proxy — volitelný per-namespace/service Envoy proxy pro L7 (HTTP routing, AuthorizationPolicy)

┌──────────────────────────────────┐
│ Node                             │
│ ┌──────────┐                     │
│ │ ztunnel  │ ← L4: mTLS, TCP    │
│ │(DaemonSet)│                    │
│ └──────────┘                     │
│ ┌───────┐ ┌───────┐ ┌─────────┐ │
│ │ Pod A │ │ Pod B │ │Waypoint │ │
│ └───────┘ └───────┘ │ (opt.)  │ │
│                      └─────────┘ │
└──────────────────────────────────┘

Proč je to revoluce: - mTLS bez sidecar — ztunnel poskytuje šifrování na L4 bez jakékoli injekce - L7 jen kde potřebujete — waypoint proxy se nasadí jen pro služby vyžadující HTTP routing - 60–70 % snížení resource overhead oproti klasickému sidecar modelu - Zero config mTLS — přidáte label na namespace a hotovo

Velká trojka: Istio vs Cilium vs Linkerd¶

Istio — enterprise standard¶

Istio je nejrozšířenější service mesh s největším ekosystémem. V roce 2026 je ve verzi 1.25+ s plnou podporou Ambient mode.

Silné stránky: - Nejširší feature set — traffic management, security, observability - Masivní komunita a enterprise podpora (Google, Solo.io, Tetrate) - Ambient mode eliminuje hlavní bolest (sidecar overhead) - Integrace s většinou cloud providerů (GKE, AKS, EKS) - Gateway API podpora (Kubernetes standard pro ingress/egress)

Slabé stránky: - Strmá learning curve — CRDs, Envoy konfigurace, debugging - Control plane overhead (istiod je relativně těžký) - Historický bagáž — spousta deprecated API a konfiguračních vzorů

Ideální pro: Enterprise prostředí s komplexními požadavky na traffic management a multi-cluster deployments.

# Istio Ambient Mode — zapnutí mTLS pro namespace
apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    istio.io/dataplane-mode: ambient

---
# Waypoint proxy pro L7 politiky
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: production-waypoint
  namespace: production
  labels:
    istio.io/waypoint-for: service
spec:
  gatewayClassName: istio-waypoint
  listeners:
  - name: mesh
    port: 15008
    protocol: HBONE

Cilium Service Mesh — eBPF-native¶

Cilium začal jako CNI plugin pro Kubernetes a vyrostl v kompletní networking, observability a security platformu. Cilium Service Mesh je přirozeným rozšířením — využívá eBPF pro L3/L4 a Envoy per-node pro L7.

Silné stránky: - eBPF performance — nejnižší latence a overhead ze všech mesh řešení - Unified platform — CNI + service mesh + observability (Hubble) v jednom - Network policies na L3/L4/L7 — nejgranularnější v ekosystému - Hubble — real-time observability bez sidecar - Tetragon — runtime security enforcement na kernel úrovni - Mutual authentication bez sidecar proxy

Slabé stránky: - Kernel dependency (5.10+, ideálně 6.1+) - Menší L7 feature set oproti Istio (postupně dohání) - Vendor lock-in risk (Isovalent → Cisco akvizice) - Komplexnější debugging (eBPF programy vs Envoy access logs)

Ideální pro: Organizace, které chtějí unified networking stack s maximálním výkonem.

# Cilium — L7 traffic policy
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: api-l7-policy
  namespace: production
spec:
  endpointSelector:
    matchLabels:
      app: api-gateway
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: frontend
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: "/api/v1/.*"
        - method: POST
          path: "/api/v1/orders"
          headers:
          - 'Content-Type: application/json'

Linkerd — jednoduchost jako feature¶

Linkerd je nejlehčí service mesh. Používá vlastní ultra-lightweight proxy (linkerd2-proxy, napsaný v Rustu) místo Envoy.

Silné stránky: - Nejjednodušší nasazení a provoz — 5minutový install - Nejnižší resource footprint v sidecar modelu (proxy <10 MB RAM) - Rust proxy — rychlejší a bezpečnější než Envoy (C++) - Opinionated — méně konfigurace = méně chyb - CNCF graduated — vendor neutral

Slabé stránky: - Omezený feature set oproti Istio (žádné egress gateway, omezený traffic splitting) - Menší ekosystém a komunita - Licence změna (2024) — edge releases pod Buoyant Enterprise License - Žádný sidecarless/ambient mode (zůstává u sidecar)

Ideální pro: Menší týmy a organizace, kde jednoduchost > features.

# Linkerd — install za 5 minut
curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install | sh
linkerd install --crds | kubectl apply -f -
linkerd install | kubectl apply -f -
linkerd check

# Mesh namespace
kubectl annotate namespace production linkerd.io/inject=enabled
kubectl rollout restart deployment -n production

Praktické srovnání výkonu¶

Benchmarky z reálných clusterů (100 podů, 10k RPS, 2026 verze):

mTLS everywhere — zero trust networking¶

Jedna z nejdůležitějších funkcí service mesh je automatické vzájemné TLS (mTLS). V zero trust modelu se nespoléháme na síťový perimetr — každá komunikace musí být šifrovaná a autentizovaná.

Jak mTLS v service mesh funguje¶

1. Identity — každý workload dostane SPIFFE identitu (URI formát: spiffe://cluster.local/ns/production/sa/api-server)
2. Certificate issuance — control plane vydá X.509 certifikát s krátkou platností (typicky 24h)
3. Automatic rotation — certifikáty se automaticky rotují bez restartu
4. Mutual verification — obě strany komunikace ověřují certifikát protistrany

# Istio PeerAuthentication — vynucení mTLS
apiVersion: security.istio.io/v1
kind: PeerAuthentication
metadata:
  name: strict-mtls
  namespace: production
spec:
  mtls:
    mode: STRICT

---
# AuthorizationPolicy — kdo smí komunikovat s kým
apiVersion: security.istio.io/v1
kind: AuthorizationPolicy
metadata:
  name: api-access
  namespace: production
spec:
  selector:
    matchLabels:
      app: api-server
  action: ALLOW
  rules:
  - from:
    - source:
        principals:
        - "cluster.local/ns/production/sa/frontend"
        - "cluster.local/ns/production/sa/mobile-bff"
    to:
    - operation:
        methods: ["GET", "POST"]
        paths: ["/api/v1/*"]

SPIFFE a identity federation¶

SPIFFE (Secure Production Identity Framework For Everyone) standardizuje workload identity. V multi-cluster a hybrid-cloud prostředí je SPIFFE federation klíčová — umožňuje workloadům v různých clusterech vzájemně důvěřovat bez sdílení root CA.

Cluster A (on-prem)          Cluster B (cloud)
┌─────────────────┐         ┌─────────────────┐
│ Trust Domain:    │         │ Trust Domain:    │
│ cluster-a.local  │◄──────►│ cluster-b.cloud  │
│                  │ Bundle  │                  │
│ ┌─────┐ ┌─────┐│Exchange ││ ┌─────┐ ┌─────┐│
│ │Svc A│ │Svc B││         ││ │Svc C│ │Svc D││
│ └─────┘ └─────┘│         │└─────┘ └─────┘│
└─────────────────┘         └─────────────────┘

Traffic management v praxi¶

Canary deployment s automatickým rollbackem¶

# Istio VirtualService — postupný canary s metrikami
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: api-server
  namespace: production
spec:
  hosts:
  - api-server
  http:
  - match:
    - headers:
        x-canary:
          exact: "true"
    route:
    - destination:
        host: api-server
        subset: canary
  - route:
    - destination:
        host: api-server
        subset: stable
      weight: 90
    - destination:
        host: api-server
        subset: canary
      weight: 10
    retries:
      attempts: 3
      perTryTimeout: 2s
      retryOn: 5xx,reset,connect-failure
    timeout: 10s

---
# Flagger — automatický canary s rollback
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: api-server
  namespace: production
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  service:
    port: 8080
  analysis:
    interval: 1m
    threshold: 5
    maxWeight: 50
    stepWeight: 10
    metrics:
    - name: request-success-rate
      thresholdRange:
        min: 99
      interval: 1m
    - name: request-duration
      thresholdRange:
        max: 500
      interval: 1m

Fault injection pro chaos engineering¶

# Simulace latence a chyb pro testování resilience
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: payment-service-chaos
spec:
  hosts:
  - payment-service
  http:
  - fault:
      delay:
        percentage:
          value: 10
        fixedDelay: 5s
      abort:
        percentage:
          value: 5
        httpStatus: 503
    route:
    - destination:
        host: payment-service

Observability bez instrumentace¶

Service mesh poskytuje automatickou observability bez nutnosti měnit kód aplikací.

Metriky (Prometheus)¶

Service mesh automaticky generuje RED metriky (Rate, Errors, Duration) pro každou službu:

# Request rate per služba
sum(rate(istio_requests_total{reporter="destination"}[5m])) by (destination_service)

# Error rate
sum(rate(istio_requests_total{response_code=~"5.*"}[5m])) by (destination_service)
/ sum(rate(istio_requests_total[5m])) by (destination_service)

# P99 latence
histogram_quantile(0.99, 
  sum(rate(istio_request_duration_milliseconds_bucket[5m])) by (le, destination_service)
)

Distributed tracing¶

Mesh automaticky propaguje trace headers (B3, W3C Trace Context), ale aplikace musí propagovat headers mezi příchozími a odchozími requesty. Toto je častý misconception — service mesh nevytvoří end-to-end trace automaticky.

# Aplikace musí propagovat headers
from flask import Flask, request
import requests

app = Flask(__name__)

TRACE_HEADERS = [
    'x-request-id', 'x-b3-traceid', 'x-b3-spanid',
    'x-b3-parentspanid', 'x-b3-sampled', 'x-b3-flags',
    'traceparent', 'tracestate'
]

@app.route('/api/orders')
def get_orders():
    # Propagace trace headers do downstream služby
    headers = {h: request.headers.get(h) for h in TRACE_HEADERS if request.headers.get(h)}
    response = requests.get('http://inventory-service:8080/stock', headers=headers)
    return process_orders(response.json())

Hubble (Cilium) — real-time flow visibility¶

# Sledování provozu v reálném čase
hubble observe --namespace production --protocol http

# Top služby podle traffic volume
hubble observe --namespace production -o json | \
  jq -r '.flow.destination.identity' | sort | uniq -c | sort -rn | head

# Dropped connections (security policy violations)  
hubble observe --namespace production --verdict DROPPED

# Service map export pro Grafana
hubble observe --namespace production -o json > flows.json

Multi-cluster service mesh¶

Enterprise prostředí málokdy běží na jednom clusteru. Multi-cluster mesh umožňuje transparentní komunikaci mezi clustery s jednotnými bezpečnostními politikami.

Istio multi-cluster topologie¶

Primary-Remote: Jeden control plane, vzdálené clustery se připojují.

# Primary cluster — istiod řídí všechny clustery
apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
spec:
  values:
    global:
      meshID: mesh1
      multiCluster:
        clusterName: cluster1
      network: network1
  meshConfig:
    defaultConfig:
      proxyMetadata:
        ISTIO_META_DNS_CAPTURE: "true"
        ISTIO_META_DNS_AUTO_ALLOCATE: "true"

Multi-Primary: Každý cluster má vlastní control plane, synchronizace přes east-west gateway.

Cilium Cluster Mesh¶

Cilium nabízí nativní multi-cluster networking bez potřeby external gateway:

# Propojení dvou clusterů
cilium clustermesh enable --context cluster1
cilium clustermesh enable --context cluster2
cilium clustermesh connect --context cluster1 --destination-context cluster2

# Globální služba dostupná z obou clusterů
kubectl annotate service api-server \
  service.cilium.io/global="true" \
  service.cilium.io/shared="true"

Migrace na service mesh — krok za krokem¶

Fáze 1: Assessment (2 týdny)¶

1. Zmapujte služby — kolik podů, jaké protokoly (HTTP, gRPC, TCP), jaké komunikační vzory
2. Identifikujte quick wins — které služby nejvíce profitují z mTLS a observability
3. Ověřte kompatibilitu — kernel verze (pro Cilium), sidecar kompatibilita (init containers, hostNetwork)
4. Definujte success metrics — co chcete měřit (latence, security posture, MTTR)

Fáze 2: Pilot (4 týdny)¶

1. Staging cluster — nasaďte mesh na non-production prostředí
2. Permissive mTLS — začněte s PERMISSIVE mode (akceptuje i plaintext)
3. Observability first — nasaďte dashboardy, naučte tým číst metriky
4. Jeden namespace — začněte s nekritickým namespace v produkci

Fáze 3: Rollout (8–12 týdnů)¶

1. Namespace by namespace — postupné zapínání mesh
2. Strict mTLS — přepněte na STRICT po ověření, že vše komunikuje přes mTLS
3. Authorization policies — postupně přidávejte L7 politiky
4. Traffic management — canary deployments, fault injection testy

Fáze 4: Hardening (ongoing)¶

1. Default deny — AuthorizationPolicy s allow-list přístupem
2. Audit logging — access logs pro compliance
3. Performance tuning — right-sizing proxy resources, connection pooling
4. DR testing — simulace výpadků control plane

Časté chyby a jak se jim vyhnout¶

1. Nasazení mesh na vše najednou¶

Největší chyba. Mesh přidává složitost a nový failure mode. Pokud ho nasadíte na celý cluster naráz a něco se rozbije, nemáte baseline pro srovnání.

Řešení: Namespace by namespace, s rollback plánem.

2. Ignorování resource limitů proxy¶

Envoy sidecar bez resource limitů může spotřebovat víc CPU a RAM než samotná aplikace.

# Nastavení resource limitů pro sidecar
apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
spec:
  meshConfig:
    defaultConfig:
      proxyMetadata: {}
  values:
    global:
      proxy:
        resources:
          requests:
            cpu: 50m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 256Mi

3. Nepropagování trace headers¶

Service mesh generuje spany, ale end-to-end trace funguje jen pokud aplikace propaguje headers. Bez toho máte izolované spany místo souvislého trace.

4. mTLS breakage s external služba¶

Služby mimo mesh (databáze, external API) nemohou komunikovat přes mTLS. Potřebujete DestinationRule s DISABLE TLS pro external služby.

apiVersion: networking.istio.io/v1
kind: DestinationRule
metadata:
  name: external-database
spec:
  host: database.external.svc
  trafficPolicy:
    tls:
      mode: DISABLE

5. Podcenění day-2 operations¶

Upgrade service mesh je komplexní operace. Control plane a data plane musí být kompatibilní, sidecar proxy vyžadují rolling restart. Automatizujte upgrade pipeline od začátku.

Budoucnost: kam service mesh směřuje¶

eBPF jako default¶

Do konce roku 2026 predikujeme, že většina nových nasazení bude eBPF-based. Sidecar model přežije pro L7-heavy use cases, ale L3/L4 přejde do kernelu.

Gateway API jako standard¶

Kubernetes Gateway API (GA od K8s 1.27) nahrazuje Ingress a proprietární CRDs. Service mesh implementace konvergují k jednotnému API pro traffic management.

Ambient mesh mainstream¶

Istio Ambient mode odstraní největší bariéru adopce (sidecar overhead). Predikujeme 50%+ nových Istio instalací v Ambient mode do konce 2026.

AI-driven traffic management¶

Prediktivní autoscaling a traffic routing na základě ML modelů analyzujících historické metriky. Automatický circuit breaking na základě anomaly detection místo statických thresholdů.

Konsolidace trhu¶

Cisco akvizice Isovalent (Cilium), Solo.io dominance v Istio enterprise. Očekáváme další konsolidaci — možná merge Linkerd do jiného projektu nebo jeho marginalizace.

Doporučení CORE SYSTEMS¶

Na základě desítek implementací service mesh doporučujeme:

1. Nová nasazení (greenfield): Cilium Service Mesh — unified stack, nejlepší výkon, budoucnost je eBPF
2. Existující Kubernetes s Istio: Migrace na Ambient mode — okamžité snížení overhead bez ztráty funkcí
3. Malé týmy, jednoduché požadavky: Linkerd — nejrychlejší time-to-value
4. Multi-cloud / hybrid: Istio — nejlepší multi-cluster podpora a ekosystém
5. Vysoký výkon / low latency: Cilium — eBPF latence je nepřekonatelná

CORE SYSTEMS nabízí¶

• Service Mesh Assessment — analýza připravenosti vaší infrastruktury
• Pilot Implementation — nasazení a konfigurace mesh na pilotním projektu
• Migration Planning — strategie přechodu z monolitu nebo sidecar na ambient/eBPF
• Training — workshopy pro vývojáře i operátory
• Managed Operations — provoz a monitoring service mesh jako služba

Service mesh není silver bullet — je to infrastrukturní investice, která se vyplatí ve správném kontextu. Pokud váš cluster roste, bezpečnostní požadavky rostou a potřebujete observability bez instrumentace, service mesh je správná volba. Klíč je začít malým pilotem, měřit impact a škálovat postupně.

Potřebujete pomoc s nasazením? Kontaktujte nás — pomůžeme vám vybrat a implementovat správné řešení.