Introduction

Kubernetes has become the go-to orchestration tool for modern cloud-native applications. However, managing clusters across multiple cloud providers like AWS EKS and Google Kubernetes Engine (GKE) can be complex. To bridge this gap, I built SubbuK8sConsole — a simple web-based Kubernetes dashboard that simplifies cluster management across AWS and GCP.

This blog will walk through its features, architecture, and deployment details.

🔗 GitHub Repository: SubbuK8sConsole on GitHub

Key Features 🌟

✅ Multi-Cloud Support: Manage and monitor both AWS EKS and GKE clusters from a single interface.
✅ Cluster Insights: View real-time information about nodes, pods, deployments, and services.
✅ API-Driven Architecture: Efficient interaction with AWS, GCP, and Kubernetes APIs.
✅ Secure & Scalable: Uses Kubeconfig, AWS Boto3, and Google Cloud SDK for authentication and communication.
✅ User-Friendly UI: Built with Bootstrap, HTML, and JavaScript for seamless navigation.
✅ Flask Backend: API-powered microservices for retrieving cluster data efficiently.

Component Breakdown

Frontend Layer

Built with HTML5, CSS3, JavaScript
Responsive design using Bootstrap
Handles user interactions
Sends API requests to backend
Renders cluster and resource information

2. API Layer (Backend)

Flask-based Python web server
Manages API endpoints
Handles authentication and resource retrieval
Interfaces with cloud providers
Provides RESTful API for cluster management

3. Cloud Provider Connector

Uses boto3 for AWS interactions
Manages cluster connections
Retrieves cluster metadata
Generates dynamic kubeconfig
Handles authentication methods

How It Works? (Data Flow) 🔄

Step 1: User Interaction

The user accesses the SubbuK8sConsole via a web UI.
They can select either AWS EKS or GKE clusters to connect.

Step 2: Backend API Communication

The Flask API processes the user request and connects with either AWS Boto3 SDK or Google Cloud SDK.
The Kubernetes Client fetches relevant cluster data from the Kubernetes API.

Step 3: Data Visualization

The retrieved cluster details (nodes, pods, deployments, services) are displayed in the dashboard UI.
The user can explore detailed cluster information interactively.

Architecture Overview 🏗️

The architecture of SubbuK8sConsole follows a modular design that enables scalability and flexibility across different cloud environments.

Basic-component-diagram:

Simplified-Component-Diagram:

Architecture:

API Workflow and Interaction Patterns

Cluster Discovery Workflow:

Cluster Connection Workflow:

Resource Retrieval Workflow:

API Endpoints Overview

Authentication Methods

1. AWS Credentials Authentication

Direct AWS access key authentication
Supports temporary session tokens
Provides granular access control

2. AWS Profile Authentication

Uses pre-configured AWS profiles
Simplifies credential management
Default profile support

Error Handling

The API provides comprehensive error responses:

Detailed error messages
Appropriate HTTP status codes
Logging for backend diagnostics

Security Considerations

Credential Management:

Supports multiple authentication methods
Temporary credential support
No long-term credential storage

2. API Security

CORS support
Minimal persistent state
Stateless resource retrieval

Deployment Considerations

Supports containerized deployment
Compatible with various hosting environments
Minimal infrastructure requirements

Future Enhancements

Multi-cloud support expansion
Enhanced authentication mechanisms
Advanced resource management features
Persistent cluster connection state
Real-time cluster monitoring

Getting Started

Configure AWS credentials
Install dependencies
Start the application
Discover and connect to clusters
Explore Kubernetes resources

Troubleshooting

Verify AWS credentials
Check network connectivity
Review application logs
Ensure proper IAM permissions

How to Deploy SubbuK8sConsole? 🚀

Clone the Repository:

git clone https://github.com/SubbuTechOps/python-k8s-console-ui.git
cd subbu-k8s-console

2. Install Dependencies:

pip install -r requirements.txt

3. Run the Flask Backend:

cd ./python-k8s-console-ui/backend
python app.py

4. Access the Dashboard:

Open your browser and navigate to:

http://localhost:8000

Application Images:

Listed Clusters:

Pods:

Deployments:

Services:

Nodes:

AWS Dashboard-Connect to Cluster:

Discover EKS Cluster:

API Test Console:

API Test Health:

API Test List Clusters:

API Test Discover Clusters:

API Test Connect to Cluster:

API Test List Pods:

Conclusion 🎯

SubbuK8sConsole makes Kubernetes cluster management effortless by providing a unified AWS EKS and GKE dashboard. With a simple UI, robust API architecture, and seamless cloud integration, this tool empowers DevOps engineers and cloud architects to monitor and manage their Kubernetes workloads efficiently.

🔹 Let me know what you think in the comments!
🔹 Feel free to contribute to the project if you’re interested.