### Install Helm Chart with Example Configurations

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Install the MCP Server Helm chart using various example configuration files tailored for different cloud provider integrations and security settings.

```bash
# AWS Multi-cluster with role assumption
helm install mcp-server ./helm-chart -f examples/aws-multi-cluster.yaml

# AWS IRSA integration
helm install mcp-server ./helm-chart -f examples/aws-irsa-example.yaml

# GCP Workload Identity  
helm install mcp-server ./helm-chart -f examples/gcp-workload-identity.yaml

# Azure Workload Identity
helm install mcp-server ./helm-chart -f examples/azure-workload-identity.yaml

# Secure NetworkPolicy with default deny
helm install mcp-server ./helm-chart -f examples/secure-networkpolicy.yaml

# Complete production configuration
helm install mcp-server ./helm-chart -f examples/production-complete.yaml
```

--------------------------------

### Complete Environment Setup Example

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Demonstrates two options for setting up the environment for production clusters: using minimal config with overrides, or using a custom kubeconfig path with overrides.

```bash
# Option 1: Using minimal config with overrides
export K8S_SERVER='https://prod-cluster.example.com'
export K8S_TOKEN='eyJhbGciOiJSUzI1NiIsImtpZCI6...'
export K8S_CA_DATA='LS0tLS1CRUdJTi...'  # base64-encoded CA certificate
export K8S_CONTEXT='production'
export K8S_NAMESPACE='my-app'
export K8S_SKIP_TLS_VERIFY='false'

# Option 2: Using custom kubeconfig path
export KUBECONFIG_PATH='/etc/kubernetes/prod-config'
export K8S_CONTEXT='production'
export K8S_NAMESPACE='my-app'
```

--------------------------------

### Template Mode Installation with Values File

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/helm-install.md

Employ template mode for installations when direct Helm authentication or API version mismatches occur. This example uses a local chart, specifies a values file, and disables automatic namespace creation.

```json
{
  "name": "my-release",
  "chart": "./local-chart",
  "namespace": "my-namespace",
  "useTemplate": true,
  "valuesFile": "/path/to/values.yaml",
  "createNamespace": false
}
```

--------------------------------

### Basic Helm Installation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP Server using Helm with default settings. Use the second command to install into a specific namespace, creating it if it doesn't exist.

```bash
helm install mcp-server ./helm-chart
```

```bash
helm install mcp-server ./helm-chart -n mcp-system --create-namespace
```

--------------------------------

### Run Jaeger and Enable Telemetry for MCP Kubernetes

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This example demonstrates how to start a Jaeger instance using Docker and then enable telemetry for the MCP Kubernetes server to send traces to Jaeger.

```bash
# Start Jaeger
docker run -d --name jaeger \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 16686:16686 \
  -p 4317:4317 \
  jaegertracing/all-in-one:latest

# Enable telemetry
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_TRACES_SAMPLER=always_on

# Run server
npx mcp-server-kubernetes

# View traces: http://localhost:16686
```

--------------------------------

### Clone Repo and Install Dependencies

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Use these bash commands to clone the repository and install the necessary Node.js dependencies using Bun.

```bash
git clone https://github.com/Flux159/mcp-server-kubernetes.git
cd mcp-server-kubernetes
bun install
```

--------------------------------

### Install and Test MCP Server

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Basic commands to install the MCP server chart and run its automated tests.

```bash
helm install mcp-server ./helm-chart
helm test mcp-server
```

--------------------------------

### Test AWS Multi-Cluster Setup

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP server with a specific values file for AWS multi-cluster environments and runs tests, including displaying logs.

```bash
helm install mcp-server ./helm-chart -f examples/aws-multi-cluster.yaml
helm test mcp-server --logs
```

--------------------------------

### Local Chart Installation in Template Mode

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/helm-install.md

This configuration demonstrates installing a local chart using template mode. It includes inline values and targets a specific namespace for the deployment.

```json
{
  "name": "my-app",
  "chart": "./charts/my-application",
  "namespace": "production",
  "useTemplate": true,
  "values": {
    "environment": "production",
    "replicas": 3
  }
}
```

--------------------------------

### Standard Helm Chart Installation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/helm-install.md

Use this configuration for a standard Helm installation with inline values. Specify the release name, chart, repository, namespace, and any custom values.

```json
{
  "name": "my-release",
  "chart": "stable/nginx-ingress",
  "repo": "https://kubernetes-charts.storage.googleapis.com",
  "namespace": "ingress-nginx",
  "values": {
    "replicaCount": 2,
    "service": {
      "type": "LoadBalancer"
    }
  }
}
```

--------------------------------

### Run Chat Interface

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Execute this command to start the chat interface for interacting with the server.

```bash
bun run chat
```

--------------------------------

### Run Server in Development Mode

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Execute this command to start the server in development mode, which includes watching for file changes.

```bash
bun run dev
```

--------------------------------

### Volume-based Kubeconfig Installation (CLI)

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP Server using a kubeconfig file provided via a volume mount. This method is useful for pre-existing Secrets or ConfigMaps.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set kubeconfig.provider=volume \
  --set kubeconfig.volume.path=/home/node/.kube/config \
  --set kubeconfig.volume.volumeSpec.name=kubeconfig \
  --set kubeconfig.volume.volumeSpec.secret.secretName=my-kubeconfig-secret \
  --set kubeconfig.volume.volumeMountSpec.name=kubeconfig \
  --set kubeconfig.volume.volumeMountSpec.mountPath=/home/node/.kube \
  --set kubeconfig.volume.volumeMountSpec.readOnly=true
```

--------------------------------

### Local Testing with Inspector

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Use this command to start the server locally and connect with the Inspector tool. Follow the on-screen instructions for the Inspector link.

```bash
npx @modelcontextprotocol/inspector node dist/index.js
```

--------------------------------

### URL-based Kubeconfig Installation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP Server using kubeconfig files fetched from specified URLs. Ensure the URLs are accessible and the files contain valid kubeconfig content.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set kubeconfig.provider=url \
  --set kubeconfig.url.configs[0].name=prod-config \
  --set kubeconfig.url.configs[0].url="https://storage.company.com/prod.yaml" \
  --set kubeconfig.url.configs[1].name=staging-config \
  --set kubeconfig.url.configs[1].url="https://storage.company.com/staging.yaml"
```

--------------------------------

### Install MCP Kubernetes as a Gemini CLI extension

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Install the MCP Kubernetes repository as an extension using Gemini CLI. This allows for easier management and integration.

```shell
gemini extensions install https://github.com/Flux159/mcp-server-kubernetes
```

--------------------------------

### Jaeger Backend Setup

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Docker command to run a Jaeger all-in-one instance with OTLP enabled.

```bash
docker run -d --name jaeger \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 16686:16686 \
  -p 4317:4317 \
  jaegertracing/all-in-one:latest
```

--------------------------------

### Start Jaeger for Local Testing

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Run a local Jaeger instance using Docker or Podman to collect and visualize traces during development. This setup exposes the OTLP collector endpoint on port 4317.

```bash
# Using Docker
docker run -d --name jaeger \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 16686:16686 \
  -p 4317:4317 \
  jaegertracing/all-in-one:latest

# Using Podman
podman run -d --name jaeger \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 16686:16686 \
  -p 4317:4317 \
  docker.io/jaegertracing/all-in-one:latest
```

--------------------------------

### Disable Observability (Before)

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Example of the environment configuration before enabling observability.

```yaml
env: []
```

--------------------------------

### Example Span JSON

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

An example of a span generated by OpenTelemetry, detailing method calls, tool execution, and Kubernetes resource information.

```json
{
  "spanName": "tools/call kubectl_get",
  "duration": "1915ms",
  "attributes": {
    "mcp.method.name": "tools/call",
    "gen_ai.tool.name": "kubectl_get",
    "gen_ai.operation.name": "execute_tool",
    "tool.duration_ms": 1915,
    "tool.argument_count": 3,
    "tool.argument_keys": "resourceType,namespace,output",
    "k8s.namespace": "default",
    "k8s.resource_type": "deployments",
    "response.k8s_items_count": 92,
    "response.text_size_bytes": 16851,
    "response.content_type": "text"
  },
  "status": "OK"
}
```

--------------------------------

### Helm Template Example: Security Settings Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/templates/NOTES.txt

This Helm template snippet demonstrates how to configure security settings, including options for non-destructive tools, read-only tools, allowed tools, and enabling all tools.

```go-template
   Security Settings:
   {{- if .Values.security.allowOnlyNonDestructive }}
   - Non-destructive tools only: ENABLED
   {{- end }}
   {{- if .Values.security.allowOnlyReadonly }}
   - Read-only tools only: ENABLED
   {{- end }}
   {{- if .Values.security.allowedTools }}
   - Allowed tools: {{ .Values.security.allowedTools }}
   {{- end }}
   {{- if not (or .Values.security.allowOnlyNonDestructive .Values.security.allowOnlyReadonly .Values.security.allowedTools) }}
   - All tools enabled (full access)
   {{- end }}
```

--------------------------------

### Describe Test Pods

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Commands to get detailed information about test pods for troubleshooting.

```bash
kubectl describe pod mcp-server-test-connectivity
```

--------------------------------

### Kubernetes Resource Limits for Observability

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Example Kubernetes resource requests and limits for a deployment, including estimated overhead for telemetry.

```yaml
resources:
  requests:
    memory: "128Mi"  # Add ~10MB for telemetry
    cpu: "100m"      # Add ~10m for telemetry
  limits:
    memory: "512Mi"
    cpu: "500m"
```

--------------------------------

### Install with GCP Workload Identity

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Install the Helm chart enabling GCP Workload Identity. Specify the GCP service account email for authentication.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set serviceAccount.annotations."iam\.gke\.io/gcp-service-account"="mcp-server@my-project.iam.gserviceaccount.com"
```

--------------------------------

### Install with AWS IRSA

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Install the Helm chart enabling AWS IAM Roles for Service Accounts (IRSA). Ensure the specified IAM role ARN is correctly configured in AWS.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set serviceAccount.annotations."eks\.amazonaws\.com/role-arn"="arn:aws:iam::123456789012:role/mcp-server-role" \
  --set serviceAccount.annotations."eks\.amazonaws\.com/sts-regional-endpoints"="true"
```

--------------------------------

### AWS EKS Multi-Cluster Installation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP Server on AWS EKS, configuring multiple clusters and a default context. Ensure the specified role ARN has the necessary permissions.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set kubeconfig.provider=aws \
  --set kubeconfig.aws.clusters[0].name=prod-us-east \
  --set kubeconfig.aws.clusters[0].clusterName=prod-cluster \
  --set kubeconfig.aws.clusters[0].region=us-east-1 \
  --set kubeconfig.aws.clusters[0].roleArn="arn:aws:iam::123456789:role/EKSAdminRole" \
  --set kubeconfig.aws.clusters[1].name=staging-us-west \
  --set kubeconfig.aws.clusters[1].clusterName=staging-cluster \
  --set kubeconfig.aws.clusters[1].region=us-west-2 \
  --set kubeconfig.aws.defaultContext=prod-us-east
```

--------------------------------

### Helm Template Apply Tool Usage Example

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/helm-template-apply.md

Use this JSON configuration to invoke the helm_template_apply tool. It specifies the release name, chart path, namespace, and values file for the deployment.

```json
{
  "name": "events-exporter",
  "arguments": {
    "name": "events-exporter",
    "chart": ".",
    "namespace": "kube-event-exporter",
    "valuesFile": "values.yaml",
    "createNamespace": true
  }
}
```

--------------------------------

### Grafana Tempo Backend Setup

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

YAML configuration for Grafana Tempo to enable OTLP gRPC reception on port 4317.

```yaml
# tempo.yaml
server:
  http_listen_port: 3200
distributor:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: 0.0.0.0:4317
```

--------------------------------

### Install with Non-Destructive Mode

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Install the Helm chart with non-destructive mode enabled, ensuring only safe operations are allowed.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set security.allowOnlyNonDestructive=true
```

--------------------------------

### GCP GKE Multi-Cluster Installation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP Server on GCP GKE, configuring multiple clusters with their respective zones and projects. Verify that the service account has the required access.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set kubeconfig.provider=gcp \
  --set kubeconfig.gcp.clusters[0].name=prod-cluster \
  --set kubeconfig.gcp.clusters[0].clusterName=prod-gke \
  --set kubeconfig.gcp.clusters[0].zone=us-central1-a \
  --set kubeconfig.gcp.clusters[0].project=company-prod \
  --set kubeconfig.gcp.clusters[1].name=dev-cluster \
  --set kubeconfig.gcp.clusters[1].clusterName=dev-gke \
  --set kubeconfig.gcp.clusters[1].zone=us-central1-b \
  --set kubeconfig.gcp.clusters[1].project=company-dev
```

--------------------------------

### Test with Security Restrictions

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Installs the MCP server with security restrictions enabled and filters tests to target specific pods.

```bash
helm install mcp-server ./helm-chart --set security.allowOnlyReadonly=true
helm test mcp-server --filter name=mcp-server-test-mcp-tools
```

--------------------------------

### MCP Server Configuration for SSE

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Example MCP server configuration specifying the URL for the mcp-server-kubernetes SSE endpoint.

```json
{
  "mcpServers": {
    "mcp-server-kubernetes": {
      "url": "http://localhost:3001/sse",
      "args": []
    }
  }
}
```

--------------------------------

### Reduce Sampling Rate for Performance

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Set the OTEL_TRACES_SAMPLER to 'traceidratio' and specify a sampling argument to reduce overhead. This example sets sampling to 1%.

```bash
export OTEL_TRACES_SAMPLER=traceidratio
export OTEL_TRACES_SAMPLER_ARG=0.01  # 1% sampling
```

--------------------------------

### Run Server in Non-Destructive Mode

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This command starts the server with the `ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS` environment variable set to `true`, disabling destructive operations.

```shell
ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS=true npx mcp-server-kubernetes
```

--------------------------------

### Enable SSE Transport

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Enable Server-Sent Events (SSE) transport by setting the ENABLE_UNSAFE_SSE_TRANSPORT environment variable. This starts an http server with the /sse endpoint.

```shell
ENABLE_UNSAFE_SSE_TRANSPORT=1 npx flux159/mcp-server-kubernetes
```

--------------------------------

### Helm Template Example: Kubeconfig Provider Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/templates/NOTES.txt

This Helm template snippet shows conditional logic for configuring kubeconfig based on the provider type. It handles URL, ServiceAccount, content, and custom command configurations.

```go-template
{{- else if eq .Values.kubeconfig.provider "url" }}
   URL Configs: {{ len .Values.kubeconfig.url.configs }}
   {{- range .Values.kubeconfig.url.configs }}
   - {{ .name }}: {{ .url }}
   {{- end }}
   {{- else if eq .Values.kubeconfig.provider "serviceaccount" }}
   Using ServiceAccount: {{ include "mcp-server-kubernetes.serviceAccountName" . }}
   {{- else if eq .Values.kubeconfig.provider "content" }}
   Using provided kubeconfig content
   {{- else if eq .Values.kubeconfig.provider "custom" }}
   Using custom command: {{ .Values.kubeconfig.custom.command }}
   {{- end }}
```

--------------------------------

### Helm Template Example: RBAC Note for ServiceAccount

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/templates/NOTES.txt

This Helm template snippet provides a note regarding RBAC permissions when the ServiceAccount provider is used for kubeconfig. It reminds the user to ensure the ServiceAccount has the necessary permissions.

```go-template
{{- if eq .Values.kubeconfig.provider "serviceaccount" }}
5. RBAC Note:
   The server is using the ServiceAccount: {{ include "mcp-server-kubernetes.serviceAccountName" . }}
   Make sure it has the required permissions for your intended operations.
{{- end }}
```

--------------------------------

### Enable Horizontal Pod Autoscaler

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Install the Helm chart enabling the Horizontal Pod Autoscaler (HPA) with specified CPU and memory utilization targets.

```bash
# Enable HPA with CPU and memory scaling
helm install mcp-server-k8s ./helm-chart \
  --set autoscaling.enabled=true \
  --set autoscaling.minReplicas=2 \
  --set autoscaling.maxReplicas=20 \
  --set autoscaling.targetCPUUtilizationPercentage=70 \
  --set autoscaling.targetMemoryUtilizationPercentage=80
```

--------------------------------

### Enable Streamable HTTP Transport

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Enable streamable HTTP transport by setting the ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT environment variable to 1. This starts an HTTP server with the /mcp endpoint for streamable HTTP events.

```shell
ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT=1 npx flux159/mcp-server-kubernetes
```

--------------------------------

### HTTP Transport with NGINX Ingress

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Sets up HTTP transport with NGINX Ingress, enabling streaming support by configuring proxy timeouts and disabling buffering. Ensure the NGINX Ingress controller is installed.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set transport.mode=http \
  --set transport.ingress.enabled=true \
  --set transport.ingress.className="nginx" \
  --set transport.ingress.annotations."nginx\.ingress\.kubernetes\.io/proxy-read-timeout"="3600" \
  --set transport.ingress.annotations."nginx\.ingress\.kubernetes\.io/proxy-buffering"="off"
```

--------------------------------

### Volume-based Kubeconfig Installation (Values File)

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Configures the MCP Server to use a volume-based kubeconfig via a values file. This is suitable for managing kubeconfig within Kubernetes Secrets or ConfigMaps.

```yaml
kubeconfig:
  provider: volume
  volume:
    path: /home/node/.kube/config
    volumeSpec:
      name: kubeconfig
      secret:
        secretName: my-kubeconfig-secret
    volumeMountSpec:
      name: kubeconfig
      mountPath: /home/node/.kube
      readOnly: true
```

--------------------------------

### Configure Kubernetes MCP Server in VS Code

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This JSON configuration is used within VS Code extensions that support the Model Context Protocol to set up the Kubernetes MCP server. Ensure you have a compatible MCP extension installed.

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"],
      "description": "Kubernetes cluster management and operations"
    }
  }
}
```

--------------------------------

### Run Helm Tests for MCP Server Deployment

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Execute Helm tests to validate the installed MCP Server deployment, with options for detailed output or filtering specific tests.

```bash
# Run all tests
helm test mcp-server

# Run tests with detailed output
helm test mcp-server --logs

# Run specific test
helm test mcp-server --filter name=mcp-server-test-connectivity
```

--------------------------------

### Get Pods with Specific Conditions using kubectl_get

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/pod-cleanup.md

Retrieve pods based on specific conditions, such as not being ready. This helps in diagnosing pods that are stuck or not functioning as expected.

```json
{
  "name": "kubectl_get",
  "arguments": {
    "resourceType": "pods",
    "namespace": "default",
    "fieldSelector": "status.conditions[?(@.type=='Ready')].status=False"
  }
}
```

--------------------------------

### Build Project

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Run this command to build the project for production.

```bash
bun run build
```

--------------------------------

### Describe Pods for Init Container Issues

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Describes pods to investigate issues related to the init container, often related to credentials or permissions.

```bash
kubectl describe pod -l app.kubernetes.io/name=mcp-server-kubernetes
```

--------------------------------

### Configure Production Observability

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Configure production observability with percentage-based sampling to balance trace data volume and cost. Set a custom service name and resource attributes for better organization in your tracing backend.

```bash
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://tempo.observability:4317
export OTEL_TRACES_SAMPLER=traceidratio
export OTEL_TRACES_SAMPLER_ARG=0.05
export OTEL_SERVICE_NAME=kubernetes-mcp-server
export OTEL_RESOURCE_ATTRIBUTES="deployment.environment=production,k8s.cluster=prod-us-west"
```

--------------------------------

### Claude Desktop Configuration with Environment Variables

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Configure Claude Desktop for Kubernetes production using environment variables within the mcpServers configuration.

```json
{
  "mcpServers": {
    "kubernetes-prod": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"],
      "env": {
        "K8S_SERVER": "https://prod-cluster.example.com",
        "K8S_TOKEN": "your-token-here",
        "K8S_CA_DATA": "LS0tLS1CRUdJTi...",
        "K8S_CONTEXT": "production",
        "K8S_NAMESPACE": "my-app"
      }
    }
  }
}
```

--------------------------------

### Run Unit Tests

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This command executes the project's unit tests using Bun.

```bash
bun run test
```

--------------------------------

### Cordon Multiple Nodes

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/node-management.md

Marks a specific node as unschedulable. This example demonstrates cordoning a single node.

```json
{
  "operation": "cordon",
  "nodeName": "worker-node-1"
}
```

--------------------------------

### Equivalent Bash Commands for Helm Template Apply

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/helm-template-apply.md

This bash script demonstrates the equivalent commands executed by the helm_template_apply tool. It first generates the YAML manifest and then applies it to the specified namespace.

```bash
helm template events-exporter . -f values.yaml > events-exporter.yaml
kubectl create namespace kube-event-exporter
kubectl apply -f events-exporter.yaml -n kube-event-exporter
```

--------------------------------

### Enable OpenTelemetry Observability with Environment Variables

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Enable OpenTelemetry integration for observability by setting environment variables. This allows for distributed tracing and export to OTLP backends.

```bash
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

npx mcp-server-kubernetes
```

--------------------------------

### Local Testing with Claude Desktop Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This JSON configuration is used for setting up local testing with Claude Desktop, specifying the command and arguments to run the mcp-server-kubernetes.

```json
{
  "mcpServers": {
    "mcp-server-kubernetes": {
      "command": "node",
      "args": ["/path/to/your/mcp-server-kubernetes/dist/index.js"]
    }
  }
}
```

--------------------------------

### Allow Specific Tools with ALLOWED_TOOLS

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Specify a comma-separated list of tool names to enable only those specific tools. This provides fine-grained control over the server's capabilities.

```shell
ALLOWED_TOOLS="kubectl_get,kubectl_describe" npx mcp-server-kubernetes
```

```json
{
  "mcpServers": {
    "kubernetes-custom": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"],
      "env": {
        "ALLOWED_TOOLS": "kubectl_get,kubectl_describe,kubectl_logs"
      }
    }
  }
}
```

--------------------------------

### Get Completed Pods using kubectl_get

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/pod-cleanup.md

Use this command to identify pods that have successfully completed their execution. Specify the correct namespace.

```json
{
  "name": "kubectl_get",
  "arguments": {
    "resourceType": "pods",
    "namespace": "default",
    "fieldSelector": "status.phase=Succeeded"
  }
}
```

--------------------------------

### Get Failed Pods using kubectl_get

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/pod-cleanup.md

Use this command to identify pods that are in a 'Failed' state. Ensure the namespace is correctly specified.

```json
{
  "name": "kubectl_get",
  "arguments": {
    "resourceType": "pods",
    "namespace": "default",
    "fieldSelector": "status.phase=Failed"
  }
}
```

--------------------------------

### Enable Network Policy with Default Deny

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Enable NetworkPolicy with a default deny configuration and specify minimal required access for ingress and egress traffic.

```bash
# Enable NetworkPolicy with default deny and minimal required access
helm install mcp-server-k8s ./helm-chart \
  --set networkPolicy.enabled=true \
  --set networkPolicy.ingress[0].from[0].namespaceSelector.matchLabels.name=ingress-nginx \
  --set networkPolicy.ingress[0].ports[0].protocol=TCP \
  --set networkPolicy.ingress[0].ports[0].port=3001 \
  --set networkPolicy.egress[0].to[0].namespaceSelector.matchLabels.name=kube-system \
  --set networkPolicy.egress[0].ports[0].protocol=UDP \
  --set networkPolicy.egress[0].ports[0].port=53

# ⚠️  WARNING: NetworkPolicy uses default deny - you MUST define egress rules 
# for DNS, Kubernetes API, and cloud provider APIs or the pod won't function!
```

--------------------------------

### Production Sampling Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Environment variables to configure trace sampling in production to reduce costs. Sets the sampler to traceidratio with a 5% sampling rate.

```bash
export OTEL_TRACES_SAMPLER=traceidratio
export OTEL_TRACES_SAMPLER_ARG=0.05  # 5% sampling
```

--------------------------------

### Verify MCP Server Deployment

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/templates/NOTES.txt

Use this command to verify the deployment of the MCP Server by listing pods with the chart's selector labels in the specified namespace.

```bash
kubectl get pods -l "{{ include "mcp-server-kubernetes.selectorLabels" . }}" -n {{ .Release.Namespace }}
```

--------------------------------

### Configure Development Observability

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Enable 100% sampling for development and debugging purposes. This ensures all traces are captured for detailed analysis.

```bash
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_TRACES_SAMPLER=always_on
```

--------------------------------

### Set Full Kubeconfig via YAML String

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Configure authentication by setting the KUBECONFIG_YAML environment variable with your entire kubeconfig as a YAML string.

```bash
export KUBECONFIG_YAML=$(cat << 'EOF'
apiVersion: v1
kind: Config
clusters:
- cluster:
    server: https://your-cluster.example.com
    certificate-authority-data: LS0tLS1CRUdJTi...
  name: my-cluster
users:
- name: my-user
  user:
    token: eyJhbGciOiJSUzI1NiIsImtpZCI6...
contexts:
- context:
    cluster: my-cluster
    user: my-user
    namespace: default
  name: my-context
current-context: my-context
EOF
)
```

--------------------------------

### Verify OTEL_TRACES_SAMPLER Setting

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Check the value of the OTEL_TRACES_SAMPLER environment variable to ensure it's not set to 'always_off'.

```bash
echo $OTEL_TRACES_SAMPLER  # Should not be "always_off"
```

--------------------------------

### Set Minimal K8s Server and Token Authentication

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Use K8S_SERVER and K8S_TOKEN for minimal environment-based authentication. Optionally provide K8S_CA_DATA for TLS verification or K8S_SKIP_TLS_VERIFY to disable it.

```bash
export K8S_SERVER='https://your-cluster.example.com'
export K8S_TOKEN='eyJhbGciOiJSUzI1NiIsImtpZCI6...'
export K8S_CA_DATA='LS0tLS1CRUdJTi...'  # optional, base64-encoded CA certificate
export K8S_SKIP_TLS_VERIFY='false'  # optional, defaults to false
```

--------------------------------

### HTTP Transport with LoadBalancer and Ingress

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Sets up HTTP transport for MCP Server with a LoadBalancer service type and an Ingress resource. Customize the host as needed.

```bash
helm install mcp-server-k8s ./helm-chart \
  --set transport.mode=http \
  --set transport.service.type=LoadBalancer \
  --set transport.ingress.enabled=true \
  --set transport.ingress.hosts[0].host=mcp-server.company.com
```

--------------------------------

### View MCP Server Logs

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/templates/NOTES.txt

Use this command to view the logs of the MCP Server pods using the chart's selector labels in the specified namespace.

```bash
kubectl logs -l "{{ include "mcp-server-kubernetes.selectorLabels" . }}" -n {{ .Release.Namespace }}
```

--------------------------------

### Run SSE Mode with Docker

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Run mcp-server-kubernetes in SSE mode using Docker, mapping ports, setting environment variables, and mounting the kubeconfig file.

```shell
docker  run --rm -it -p 3001:3001 -e ENABLE_UNSAFE_SSE_TRANSPORT=1  -e PORT=3001   -v ~/.kube/config:/home/appuser/.kube/config   flux159/mcp-server-kubernetes:latest
```

--------------------------------

### Verify NetworkPolicy Rules

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Commands to inspect NetworkPolicy resources and describe specific policies.

```bash
kubectl get networkpolicy
kubectl describe networkpolicy mcp-server-networkpolicy-tests
```

--------------------------------

### Jaeger/Tempo OTLP Endpoint Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Environment variables to configure the OpenTelemetry exporter to send data to a local Jaeger or Tempo collector.

```bash
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
```

--------------------------------

### Build Project with TypeScript Errors

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Navigate to the project directory and run the build command if you encounter TypeScript errors.

```bash
cd /path/to/mcp-server-kubernetes
npm run build
```

--------------------------------

### Enable Observability in Deployment

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Configure environment variables in your Kubernetes deployment to enable telemetry, set the OTLP endpoint, and configure sampling.

```yaml
env:
- name: ENABLE_TELEMETRY
  value: "true"
- name: OTEL_EXPORTER_OTLP_ENDPOINT
  value: "http://tempo:4317"
- name: OTEL_TRACES_SAMPLER
  value: "traceidratio"
- name: OTEL_TRACES_SAMPLER_ARG
  value: "0.05"
```

--------------------------------

### Helm Chart templates/deployment.yaml for Observability

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Integrate observability configuration from values.yaml into the Kubernetes Deployment template within a Helm chart. This dynamically sets environment variables based on Helm values.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "kubernetes-mcp-server.fullname" . }}
spec:
  template:
    spec:
      containers:
      - name: {{ .Chart.Name }}
        env:
        {{- if .Values.observability.enabled }}
        - name: ENABLE_TELEMETRY
          value: "true"
        - name: OTEL_EXPORTER_OTLP_ENDPOINT
          value: {{ .Values.observability.otlp.endpoint | quote }}
        - name: OTEL_TRACES_SAMPLER
          value: {{ .Values.observability.sampling.type | quote }}
        {{- if eq .Values.observability.sampling.type "traceidratio" }}
        - name: OTEL_TRACES_SAMPLER_ARG
          value: {{ .Values.observability.sampling.ratio | quote }}
        {{- end }}
        - name: OTEL_SERVICE_NAME
          value: {{ .Values.observability.serviceName | quote }}
        - name: OTEL_RESOURCE_ATTRIBUTES
          value: {{ include "kubernetes-mcp-server.resourceAttributes" . | quote }}
        {{- end }}
```

--------------------------------

### Set Full Kubeconfig via JSON String

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Configure authentication by setting the KUBECONFIG_JSON environment variable with your entire kubeconfig as a JSON string.

```bash
export KUBECONFIG_JSON='{"apiVersion":"v1","kind":"Config","clusters":[{"cluster":{"server":"https://your-cluster.example.com"},"name":"my-cluster"}],"users":[{"name":"my-user","user":{"token":"your-token"}}],"contexts":[{"context":{"cluster":"my-cluster","user":"my-user"},"name":"my-context"}],"current-context":"my-context"}'
```

--------------------------------

### View Pod Logs

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Fetches logs from all pods belonging to the MCP server application.

```bash
kubectl logs -l app.kubernetes.io/name=mcp-server-kubernetes
```

--------------------------------

### Connect to Google GKE Clusters using Docker

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

This command connects to a Google GKE cluster by running the MCP server in Docker. It mounts kubeconfig and gcloud configurations, and sets environment variables for the GCP project and region.

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-v",
        "~/.config/gcloud:/home/appuser/.config/gcloud:ro",
        "-e",
        "CLOUDSDK_CORE_PROJECT=my-gcp-project",
        "-e",
        "CLOUDSDK_COMPUTE_REGION=us-central1",
        "flux159/mcp-server-kubernetes:latest"
      ]
    }
  }
}
```

--------------------------------

### Troubleshoot Test Pod Logs

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Commands to retrieve logs from specific test pods for debugging.

```bash
kubectl logs mcp-server-test-connectivity
kubectl logs mcp-server-test-kubeconfig
kubectl logs mcp-server-test-mcp-tools
```

--------------------------------

### Configure Port and Host for Streamable HTTP Transport

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Configure the server port using the PORT environment variable and the listening interface using the HOST environment variable. Defaults are port 3000 and localhost.

```shell
ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT=1 PORT=3001 HOST=0.0.0.0 npx flux159/mcp-server-kubernetes
```

--------------------------------

### Claude Desktop Configuration for Non-Destructive Mode

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

This JSON configuration is for Claude Desktop, enabling non-destructive mode by setting the `ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS` environment variable.

```json
{
  "mcpServers": {
    "kubernetes-readonly": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"],
      "env": {
        "ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS": "true"
      }
    }
  }
}
```

--------------------------------

### Check Test Pod Network Connectivity

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Executes commands within a test pod to verify DNS resolution and service connectivity.

```bash
kubectl exec mcp-server-test-connectivity -- nslookup kubernetes.default
kubectl exec mcp-server-test-connectivity -- nc -zv mcp-server 3001
```

--------------------------------

### Configure Extra Arguments for Cloud Providers

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Provide extra arguments for cloud provider configurations, such as AWS profile and external ID.

```yaml
kubeconfig:
  aws:
    clusters:
      - name: "prod"
        clusterName: "prod-cluster"
        region: "us-east-1"
        extraArgs:
          - "--profile=production"
          - "--external-id=unique-id"
          - "--session-name=mcp-session"
```

--------------------------------

### Preview Drain Operation

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/node-management.md

Use the `dryRun: true` option to preview the effects of a drain operation without actually executing it. This is useful for verifying the impact on pods and node status.

```json
{
  "operation": "drain",
  "nodeName": "worker-node-1",
  "dryRun": true,
  "gracePeriod": 30,
  "ignoreDaemonsets": true
}
```

--------------------------------

### Grafana Cloud OTLP Endpoint Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Environment variables for configuring the OpenTelemetry exporter to send data to Grafana Cloud's OTLP gateway.

```bash
export ENABLE_TELEMETRY=true
export OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp-gateway-prod-us-central-0.grafana.net/otlp
# Add authentication headers via Grafana Cloud setup
```

--------------------------------

### Configure Kubernetes MCP Server in Claude Desktop

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/README.md

Add this JSON configuration to your Claude Desktop config file to enable the Kubernetes MCP server. This allows Claude Desktop to connect to and manage your Kubernetes cluster.

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"]
    }
  }
}
```

--------------------------------

### Local Usage with Default DNS Rebinding Protection

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

For local usage, the default DNS rebinding protection allowlist typically works without additional configuration. Ensure the client connects to the correct local address and port.

```shell
ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT=1 npx flux159/mcp-server-kubernetes
# Client connects to http://localhost:3000/mcp – works with the default allowlist
```

--------------------------------

### Helm Chart helpers.tpl for Resource Attributes

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Define a Helm template helper in helpers.tpl to dynamically build the OTEL_RESOURCE_ATTRIBUTES string from a map in values.yaml. This ensures resource attributes are correctly formatted for OpenTelemetry.

```go-template
{{/*
Build resource attributes string from map
*/}}
{{- define "kubernetes-mcp-server.resourceAttributes" -}}
{{- $attrs := list -}}
{{- range $key, $value := .Values.observability.resourceAttributes -}}
{{- $attrs = append $attrs (printf "%s=%s" $key $value) -}}
{{- end -}}
{{- join "," $attrs -}}
{{- end -}}
```

--------------------------------

### Enable HPA with Advanced Scaling Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/helm-chart/README.md

Configure Horizontal Pod Autoscaler with custom metrics and scaling behavior policies for both scale-up and scale-down operations.

```yaml
autoscaling:
  enabled: true
  minReplicas: 2
  maxReplicas: 50
  targetCPUUtilizationPercentage: 70
  targetMemoryUtilizationPercentage: 80
  
  # Custom metrics scaling
  customMetrics:
    - type: Pods
      pods:
        metric:
          name: http_requests_per_second
        target:
          type: AverageValue
          averageValue: "100"
  
  # Scaling behavior
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
        - type: Percent
          value: 100
          periodSeconds: 15
        - type: Pods
          value: 2
          periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 10
          periodSeconds: 60
```

--------------------------------

### Configure Max Buffer for Large Clusters

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Specify the SPAWN_MAX_BUFFER environment variable to prevent 'spawnSync ENOBFUS' errors in large clusters. The default is 1MB in Node.js.

```json
{
  "mcpServers": {
    "kubernetes-readonly": {
      "command": "npx",
      "args": ["mcp-server-kubernetes"],
      "env": {
        "SPAWN_MAX_BUFFER": "5242880" // 5MB = 1024*1024*5. Default is 1MB in Node.js
      }
    }
  }
}
```

--------------------------------

### Specify Custom Kubeconfig File Path

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Set the KUBECONFIG_PATH environment variable to point to a custom kubeconfig file.

```bash
export KUBECONFIG_PATH='/path/to/your/custom/kubeconfig'
```

--------------------------------

### Enable HTTP Transport with Auth Token

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Enable Streamable HTTP transport and set an authentication token using MCP_AUTH_TOKEN. This requires clients to send a matching X-MCP-AUTH header.

```shell
MCP_AUTH_TOKEN=my-secret-token ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT=1 npx mcp-server-kubernetes
```

--------------------------------

### Check Traces Endpoint with curl

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Use curl to send a request to the OTLP traces endpoint to verify connectivity.

```bash
curl http://localhost:4318/v1/traces
```

--------------------------------

### Connect to AWS EKS Cluster using Docker

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

This command runs the MCP server in a Docker container, mounting local kubeconfig and AWS credentials to connect to an AWS EKS cluster. Ensure you have the correct AWS profile and region configured.

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-v",
        "~/.aws:/home/appuser/.aws:ro",
        "-e",
        "AWS_PROFILE=default",
        "-e",
        "AWS_REGION=us-west-2",
        "flux159/mcp-server-kubernetes:latest"
      ]
    }
  }
}
```

--------------------------------

### Resource Attributes Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Environment variable to set custom resource attributes for filtering and analysis, including environment, cluster name, team, cost center, and version.

```bash
export OTEL_RESOURCE_ATTRIBUTES="deployment.environment=production,k8s.cluster.name=prod-us-west-2,team=platform,cost_center=engineering,version=0.1.0"
```

--------------------------------

### Run HTTP Transport with Auth via Docker

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Run mcp-server-kubernetes with Streamable HTTP transport and authentication enabled using Docker. This includes port mapping, environment variables, and kubeconfig mounting.

```shell
docker run --rm -it -p 3001:3001 \
  -e ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT=1 \
  -e PORT=3001 \
  -e MCP_AUTH_TOKEN=my-secret-token \
  -v ~/.kube/config:/home/appuser/.kube/config \
  flux159/mcp-server-kubernetes:latest
```

--------------------------------

### Secure OTLP Endpoint Configuration

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Environment variable to configure the OpenTelemetry exporter to use a secure OTLP endpoint with TLS.

```bash
export OTEL_EXPORTER_OTLP_ENDPOINT=https://tempo.observability:4317
# Add certificates if using custom CA
```

--------------------------------

### Connect to Azure AKS Clusters using Docker

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

This command uses Docker to run the MCP server and connect to an Azure AKS cluster. It mounts the kubeconfig file and sets the Azure subscription ID as an environment variable.

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-e",
        "AZURE_SUBSCRIPTION=my-subscription-id",
        "flux159/mcp-server-kubernetes:latest"
      ]
    }
  }
}
```

--------------------------------

### Helm Chart values.yaml for Observability

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/docs/OBSERVABILITY.md

Configure observability settings for the Helm chart in the values.yaml file. This allows for centralized management of telemetry, OTLP endpoint, sampling, service name, and resource attributes.

```yaml
observability:
  # Enable OpenTelemetry observability
  enabled: false  # Disabled by default

  # OTLP exporter configuration
  otlp:
    endpoint: "http://tempo-distributor.observability:4317"
    protocol: "grpc"  # or "http/protobuf"

  # Sampling configuration
  sampling:
    type: "traceidratio"  # always_on, always_off, traceidratio
    ratio: 0.05  # 5% sampling (only for traceidratio)

  # Service identification
  serviceName: "kubernetes-mcp-server"

  # Custom resource attributes
  resourceAttributes:
    deployment.environment: "production"
    k8s.cluster.name: "prod-us-west-2"
    team: "platform"
    version: "0.1.0"
```

--------------------------------

### Configure SSE Transport Port and Host

Source: https://github.com/flux159/mcp-server-kubernetes/blob/main/ADVANCED_README.md

Configure the server port and listening interface for SSE transport using PORT and HOST environment variables. This allows clients to connect to the /sse endpoint.

```shell
ENABLE_UNSAFE_SSE_TRANSPORT=1 PORT=3001 HOST=0.0.0.0 npx flux159/mcp-server-kubernetes
```