5 Minutes to Kubernetes MCP Server using Docker MCP Tookit

Join Collabnix Slack

Have you ever wished you could manage your Kubernetes clusters more easily without switching between multiple tools and terminals? Imagine managing K8s clusters using simple natural language commands instead of memorizing dozens of kubectl incantations.

Well, the wait is over.

Docker’s Model Context Protocol (MCP) Toolkit is revolutionizing how we interact with Kubernetes, bringing AI-powered simplicity to container orchestration.

The Kubernetes Management Challenge

Managing Kubernetes can sometimes feel like juggling chainsaws while riding a unicycle, right? But it doesn’t have to be that way. While Kubernetes has become the industry standard for container orchestration, its power comes with complexity that can overwhelm even experienced DevOps engineers.

The typical Kubernetes workflow involves:

Switching between multiple terminal windows
Remembering complex kubectl commands with numerous flags
Navigating between different contexts and namespaces
Constantly consulting documentation for syntax

What if you could simply ask for what you need in plain English?

Understanding the Model Context Protocol (MCP)

What is Model Context Protocol (MCP) and what problem it solves?

The Model Context Protocol (MCP) has emerged as the de facto standard for connecting AI agents to tools, enabling them to move beyond generating text to taking real-world actions. This protocol establishes a standardized way for AI assistants to interact with external tools and services, including Kubernetes clusters.

MCP solves several critical challenges in the AI tooling ecosystem:

Creates a unified interface for AI agents to access external tools
Provides a secure framework for credential management
Establishes standard patterns for tool discovery and documentation
Enables consistent interaction patterns across different AI assistants

Docker MCP Toolkit: Bringing MCP to Kubernetes

The Docker MCP (Model Context Protocol) Toolkit represents Docker’s vision for a more integrated and accessible developer experience. It provides a comprehensive solution for managing Kubernetes through AI assistants with its Kubernetes MCP Server, which can be deployed in just 5 minutes.

Key components include:

Docker MCP Catalog: A trusted hub for discovering and accessing verified MCP servers, seamlessly integrated into Docker Hub
Docker MCP Toolkit: A suite of tools and services that make MCP servers secure, seamless, and instantly usable
Kubernetes MCP Server: A specialized server providing 40 dedicated tools for Kubernetes management

Natural Language Kubernetes Management in Action

When you connect an AI assistant like Claude Desktop to your Kubernetes MCP Server, you can interact with your clusters using natural language. Here’s what that looks like:

Cluster Exploration

Instead of multiple kubectl commands, simply ask:

“Show me all nodes in my cluster and their status”
“What pods are running in the production namespace?”
“Are there any deployments that don’t have enough replicas?”

Resource Management

Natural language makes complex operations intuitive:

“Scale the frontend deployment to 5 replicas”
“Create a new namespace called ‘analytics’ and deploy Grafana there”
“Update the image version for my API deployment to v2.3.1”

Troubleshooting

When problems arise, conversational interaction shines:

“Why is this pod in a CrashLoopBackOff state?”
“Show me the logs for the database pods from the last hour”
“Compare resource usage between my staging and production environments”

Steps:

Install the latest version of Docker Desktop
Enable Kubernetes
Enable 3-Node Kind cluster
Install MCP Toolkit Extension
Configure MCP Server ( Kubernetes)
Configure the MCP Client (Claude Desktop or Gordon)

Prerequisites

Before we begin, make sure you have the following requirements in place:

Docker Desktop installed and running (the latest version is recommended)
Enable Kubernetes

Select “Kind” to setup 3-node Kind cluster on the Docker Desktop.
Click Install followed with “Apply & Restart”.
Install Docker MCP Toolkit extension through the Docker Desktop Extensions marketplace

Open Extensions under Docker Dashboard
Click “MCP Toolkit” to open up Docker MCP Toolkit
Search for Kubernetes
Select “Kubernetes” MCP Server to view all the 40 tools
Hit the toggle button to enable the Kubernetes cluster

How the Kubernetes MCP Server Works

The Kubernetes MCP server runs as a Docker container with the following configuration:

{
  "mcpServers": {
    "kubernetes": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "mcp/kubernetes"
      ]
    }
  }
}

This configuration shows how the MCP Toolkit leverages Docker’s container technology to run specialized servers. When you access the Kubernetes MCP server, the toolkit executes a container from the mcp/kubernetes image, providing a dedicated environment for Kubernetes operations.

Available Kubernetes Management Tools

The Kubernetes MCP server provides a comprehensive set of 40 tools for managing your Kubernetes resources. Here’s a breakdown of the key tools available:

Cluster Management Tools

get_current_context: Get the current Kubernetes context
list_contexts: List all available Kubernetes contexts
set_current_context: Set the current Kubernetes context
list_api_resources: List the API resources available in the cluster

Resource Creation Tools

create_namespace: Create a new Kubernetes namespace
create_pod: Create a new Kubernetes pod
create_deployment: Create a new Kubernetes deployment
create_service: Create a new Kubernetes service
create_configmap: Create a new Kubernetes ConfigMap
create_cronjob: Create a new Kubernetes CronJob

Resource Management Tools

list_namespaces: List all namespaces
list_pods: List pods in a namespace
list_deployments: List deployments in a namespace
list_services: List services in a namespace
list_nodes: List all nodes in the cluster
list_cronjobs: List CronJobs in a namespace
list_jobs: List Jobs in a namespace, optionally filtered by a CronJob parent

Detailed Information Tools

describe_pod: Describe a Kubernetes pod (read details like status, containers, etc.)
describe_deployment: Get details about a Kubernetes deployment
describe_service: Describe a Kubernetes service (read details like status, ports, selectors, etc.)
describe_node: Describe a Kubernetes node (read details like status, capacity, conditions, etc.)
describe_cronjob: Get detailed information about a Kubernetes CronJob including recent job history
explain_resource: Get documentation for a Kubernetes resource or field
get_events: Get Kubernetes events from the cluster

Update and Scale Tools

scale_deployment: Scale a Kubernetes deployment
update_deployment: Update an existing kubernetes deployment in cluster
update_service: Update an existing kubernetes service in cluster

Deletion Tools

delete_pod: Delete a Kubernetes pod
delete_deployment: Delete a Kubernetes deployment
delete_service: Delete a Kubernetes service
delete_namespace: Delete a Kubernetes namespace
delete_cronjob: Delete a Kubernetes CronJob
cleanup: Cleanup all managed resources

Helm Chart Management

install_helm_chart: Install a Helm chart
upgrade_helm_chart: Upgrade a Helm release
uninstall_helm_chart: Uninstall a Helm release

Debugging Tools

get_logs: Get logs from pods, deployments, jobs, or resources matching a label selector
get_job_logs: Get logs from Pods created by a specific Job
port_forward: Forward a local port to a port on a Kubernetes resource
stop_port_forward: Stop a port-forward process

Using Claude Deskop Client and Kubernetes MCP Server

Assuming that you have enabled Kubernetes MCP server and selected Claude Desktop, you can directly open Claude Desktop and start chatting with your Kubernetes cluster in a plain language.

Conclusion

The Docker MCP Toolkit with Kubernetes MCP Server provides a powerful yet simple way to manage Kubernetes clusters directly from your Docker Desktop environment. In just 5 minutes, you can have access to 40 specialized tools that cover everything from basic resource management to advanced operations like Helm chart deployments and port forwarding.

This approach simplifies Kubernetes management by:

Eliminating the need to install and configure multiple command-line tools
Providing a consistent interface regardless of your Kubernetes distribution
Reducing the learning curve for developers and operators new to Kubernetes
Streamlining common operations into single, intuitive commands

By leveraging the Kubernetes MCP Server, teams can focus more on their applications and less on the complexities of Kubernetes infrastructure management.