linkerd-patterns
/linkerd-patterns
Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies, or implementing zero-trust networking with minimal overhead.
- Author
- rmyndharis ↗
- Repository
- antigravity-skills ↗
- Licence
- MIT
- Last repository change
- 07.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 6
No signals detected. Repository changed on 07.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies, or implementing zero-trust networking with minimal overhead.
Original author description
Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies, or implementing zero-trust networking with minimal overhead.
How it works
- Do not use this skill when
- Instructions
- Use this skill when
- Core Concepts
- Templates
- Monitoring Commands
- Debugging
- Best Practices
- Resources
SKILL.md preview
---
name: linkerd-patterns
description: Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies, or implementing zero-trust networking with minimal overhead.
---
# Linkerd Patterns
Production patterns for Linkerd service mesh - the lightweight, security-first service mesh for Kubernetes.
## Do not use this skill when
- The task is unrelated to linkerd patterns
- You need a different domain or tool outside this scope
## Instructions
- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
## Use this skill when
- Setting up a lightweight service mesh
- Implementing automatic mTLS
- Configuring traffic splits for canary deployments
- Setting up service profiles for per-route metrics
- Implementing retries and timeouts
- Multi-cluster service mesh
## Core Concepts
### 1. Linkerd Architecture
```
┌─────────────────────────────────────────────┐
│ Control Plane │
│ ┌─────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ destiny │ │ identity │ │ proxy-inject │ │
│ └─────────┘ └──────────┘ └──────────────┘ │
└─────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────┐
│ Data Plane │
│ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │proxy│────│proxy│────│proxy│ │
│ └─────┘ └─────┘ └─────┘ │
│ │ │ │ │
│ ┌──┴──┐ ┌──┴──┐ ┌──┴──┐ │
│ │ app │ │ app │ │ app │ │
│ └─────┘ └─────┘ └─────┘ │
└─────────────────────────────────────────────┘
```
### 2. Key Resources
| Resource | Purpose |
|----------|---------|
| **ServiceProfile** | Per-route metrics, retries, timeouts |
| **HTTPRoute** | Canary deployments, A/B testing, request routing |
| **Server** | Define server-side policies |
| **AuthorizationPolicy** | Access control, with MeshTLSAuthentication or NetworkAuthentication |
## Templates
### Template 1: Mesh Installation
```bash
# Install CLI: pin a release and install it only if its SHA-256 matches the digest
# shown for that asset on https://github.com/linkerd/linkerd2/releases
# (or use a package manager: brew install linkerd)
LINKERD_VERSION=edge-26.11.1
LINKERD_ASSET="linkerd2-cli-${LINKERD_VERSION}-linux-amd64" # or -darwin-arm64, -linux-arm64
LINKERD_SHA256=f69701bec37964905d1cb06097e201ddf71e136824c3817f9a94a405fcbb6a07
curl --proto '=https' --tlsv1.2 -sSfLO \
"https://github.com/linkerd/linkerd2/releases/download/${LINKERD_VERSION}/${LINKERD_ASSET}"
echo "${LINKERD_SHA256} ${LINKERD_ASSET}" | sha256sum --strict -c - \
&& sudo install -m 0755 "${LINKERD_ASSET}" /usr/local/bin/linkerd
# Validate cluster
linkerd check --pre
# Install CRDs
linkerd install --crds | kubectl apply -f -
# Install control plane
linkerd install | kubectl apply -f -
# Verify installation
linkerd check
# Install viz extension (optional)
linkerd viz install | kubectl apply -f -
```
### Template 2: Inject Namespace
```yaml
# Automatic injection for namespace
apiVersion: v1
kind: Namespace
metadata:
name: my-app
annotations:
linkerd.io/inject: enabled
---
# Or inject specific deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
annotations:
linkerd.io/inject: enabled
spec:
template:
metadata:
annotations:
linkerd.io/inject: enabled
```
### Template 3: Service Profile with Retries
```yaml
apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
name: my-service.my-namespace.svc.cluster.local
namespace: my-namespace
spec:
routes:
- name: GET /api/users
condition:
method: GET
pathRegex: /api/users
responseClasses:
- condition:
status:
min: 500
max: 599
isFailure: true
isRetryable: true
- name: POST /api/users
condition:
method: POST
pathRegex: /api/users
# POST not retryable by default
isRetryable: false
- name: GET /api/users/{id}
condition:
method: GET
pathRegex: /api/users/[^/]+
timeout: 5s
isRetryable: true
retryBudget:
retryRatio: 0.2
minRetriesPerSecond: 10
ttl: 10s
```
### Template 4: Traffic Split (Canary)
```yaml
# Weighted HTTPRoute; SMI TrafficSplit and the linkerd-smi extension are deprecated
apiVersion: policy.linkerd.io/v1beta2
kind: HTTPRoute
metadata:
name: my-service-canary
namespace: my-namespace
spec:
parentRefs:
- name: my-service
kind: Service
group: core
port: 8080
rules:
- backendRefs:
- name: my-service-stable
port: 8080
weight: 90
- name: my-service-canary
port: 8080
weight: 10
```
### Template 5: Authorization Policy
```yaml
# Define the server
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata:
name: my-service-http
namespace: my-namespace
spec:
podSelector:
matchLabels:
app: my-service
port: http
proxyProtocol: HTTP/1
---
# Allow meshed traffic from the frontend service account
apiVersion: policy.linkerd.io/v1alpha1
kind: MeshTLSAuthentication
metadata:
name: frontend
namespace: my-namespace
spec:
identityRefs:
- kind: ServiceAccount
name: frontend
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata:
name: allow-frontend
namespace: my-namespace
spec:
targetRef:
group: policy.linkerd.io
kind: Server
name: my-service-http
requiredAuthenticationRefs:
- name: frontend
kind: MeshTLSAuthentication
group: policy.linkerd.io
---
# Allow unauthenticated traffic from the cluster network (e.g., from ingress)
apiVersion: policy.linkerd.io/v1alpha1
kind: NetworkAuthentication
metadata:
name: cluster-network
namespace: my-namespace
spec:
networks:
- cidr: 10.0.0.0/8
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata:
name: allow-ingress
namespace: my-namespace
spec:
targetRef:
group: policy.linkerd.io
kind: Server
name: my-service-http
requiredAuthenticationRefs:
- name: cluster-network
kind: NetworkAuthentication
group: policy.linkerd.io
```
### Template 6: HTTPRoute for Advanced Routing
```yaml
apiVersion: policy.linkerd.io/v1beta2
kind: HTTPRoute
metadata:
name: my-route
namespace: my-namespace
spec:
parentRefs:
- name: my-service
kind: Service
group: core
port: 8080
rules:
- matches:
- path:
type: PathPrefix
value: /api/v2
- headers:
- name: x-api-version
value: v2
backendRefs:
- name: my-service-v2
port: 8080
- matches:
- path:
type: PathPrefix
value: /api
backendRefs:
- name: my-service-v1
port: 8080
```
### Template 7: Multi-cluster Setup
```bash
# On each cluster, install with cluster credentials
linkerd multicluster install | kubectl apply -f -
# Link clusters
linkerd multicluster link --cluster-name west \
--api-server-address https://west.example.com:6443 \
| kubectl apply -f -
# Export a service to other clusters
kubectl label svc/my-service mirror.linkerd.io/exported=true
# Verify cross-cluster connectivity
linkerd multicluster check
linkerd multicluster gateways
```
## Monitoring Commands
```bash
# Live traffic view
linkerd viz top deploy/my-app
# Per-route metrics
linkerd viz routes deploy/my-app
# Check proxy status
linkerd viz stat deploy -n my-namespace
# View service dependencies
linkerd viz edges deploy -n my-namespace
# Dashboard
linkerd viz dashboard
```
## Debugging
```bash
# Check injection status
linkerd check --proxy -n my-namespace
# View proxy logs
kubectl logs deploy/my-app -c linkerd-proxy
# Debug identity/TLS
linkerd identity -n my-namespace
# Tap traffic (live)
linkerd viz tap deploy/my-app --to deploy/my-backend
```
## Best Practices
### Do's
- **Enable mTLS everywhere** - It's automatic with Linkerd
- **Use ServiceProfiles** - Get per-route metrics and retries
- **Set retry budgets** - Prevent retry storms
- **Monitor golden metrics** - Success rate, latency, throughput
### Don'ts
- **Don't skip check** - Always run `linkerd check` after changes
- **Don't over-configure** - Linkerd defaults are sensible
- **Don't ignore ServiceProfiles** - They unlock advanced features
- **Don't forget timeouts** - Set appropriate values per route
## Resources
- [Linkerd Documentation](https://linkerd.io/2.14/overview/)
- [Service Profiles](https://linkerd.io/2.14/features/service-profiles/)
- [Authorization Policy](https://linkerd.io/2.14/features/server-policy/)
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · rmyndharis/antigravity-skills | 100 | MIT |
| wshobson/agents | 100 | MIT |
Database snapshot: 13.11.2026 · package version 96959b67dc46 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90service-mesh-expert
Design service meshes with Istio or Linkerd, including traffic management, security, and observability. Use when configuring service communication, mesh policies, or multi-cluster networking. - 100service-mesh
Expert Service Mesh architecture assistance covering Istio, Linkerd, mTLS, and sidecar proxying. Use when configuring service-to-service communication, canary deployments, or zero-trust networking. - 100linkerd-expert
Expert-level Linkerd service mesh management, traffic control, reliability, and production operations. Use when the user mentions service mesh, Kubernetes, microservices, mTLS, or observability, or when the task involves Linkerd Architecture, Mesh Injection, Traffic Management,… - 100service-mesh
Compares service mesh technologies -- Istio, Linkerd, and Consul Connect -- and helps decide whether a mesh is needed at all. Use for \"service mesh\", \"Istio vs Linkerd\", \"which service mesh\", \"do I need a service mesh\", \"sidecar proxy\", \"ambient mesh\", \"mTLS\",… - 100linkerd-service-mesh-configuration
Guides installing and operating Linkerd as a simpler, mTLS-first alternative to Istio — choosing extensions deliberately, enabling automatic mutual TLS with zero-config identity, injecting the proxy per namespace/workload, and splitting traffic between service versions. Use when… - 100service-mesh
Implement Istio and Linkerd service meshes. Configure mTLS, traffic management, and observability. Use when managing microservices communication.