DEV Community

Cover image for Nanuq 2.0: Unified Management Platform for Kafka, Redis, RabbitMQ, AWS, and Azure
Wael Mansour
Wael Mansour

Posted on

Nanuq 2.0: Unified Management Platform for Kafka, Redis, RabbitMQ, AWS, and Azure

#opensource #cloudnative #devtools #programming

Managing multiple messaging and caching systems across development environments is a common pain point. Each platform requires its own CLI tools, different authentication mechanisms, and unique management interfaces. After working with teams juggling Kafka topics, Redis caches, RabbitMQ exchanges, AWS SQS queues, and Azure Service Bus—often simultaneously—I built Nanuq to solve this problem.

Today, I'm excited to share Nanuq 2.0, a major milestone that brings cloud platform support, enterprise-grade security, and production-ready features to this open-source project.

What is Nanuq?

Nanuq is a unified management interface that consolidates five critical messaging and caching platforms into a single, intuitive web UI:

  • Apache Kafka - Topic management and monitoring
  • Redis - 6 data types with full CRUD operations
  • RabbitMQ - Exchange and queue management
  • AWS (SQS/SNS) - Cloud message queuing and pub/sub
  • Azure Service Bus - Enterprise messaging with queues, topics, and subscriptions

Instead of switching between kafka-console-consumer, redis-cli, rabbitmqctl, AWS Console, and Azure Portal, developers can manage everything from one place.

Kafka Topic Management
Kafka topic management with message counts and partition details

Nanuq Dashboard - Unified view of all platforms
Unified dashboard showing metrics across all five platforms

What's New in Version 2.0

Cloud Platform Integration

The biggest addition in 2.0 is complete cloud platform support:

AWS (SQS/SNS)

  • 15 AWS regions supported (us-east-1, eu-west-1, ap-southeast-1, etc.)
  • Full SQS operations: create queues (standard/FIFO), send/receive messages, monitor queue attributes
  • SNS topic management: publish messages, manage subscriptions (HTTP, Email, SMS, SQS, Lambda)
  • Multi-region deployment for distributed teams

Azure Service Bus

  • 30+ Azure regions supported globally
  • Queue management with configurable TTL, dead-lettering, and duplicate detection
  • Topics and subscriptions with filtering capabilities
  • Complete message lifecycle: send, receive (peek-lock mode), and dead-letter queue access

AWS SQS Queue Management
Managing AWS SQS queues with send/receive capabilities

Azure Service Bus Topics
Azure Service Bus topic and subscription management

Enterprise Security

Security was a top priority for 2.0:

AES-256 Encrypted Credential Storage

All stored credentials (passwords, access keys, connection strings) are encrypted at rest using AES-256 with DPAPI-derived keys. The encryption service handles automatic encryption when credentials are saved and decryption when they're needed for API calls. Passwords are never exposed in API responses—only metadata returns to the frontend.

Connection Testing

Before saving credentials, users can test connections to verify they work. This validates that access keys, passwords, and connection strings are correct before persisting them to the database, preventing configuration errors.

Unified Dashboard

The new dashboard provides real-time visibility across all platforms:

  • Server count, topic/queue count, and resource metrics per platform
  • Environment breakdown (Development, Staging, Production) with color-coded badges
  • Recent activity feed with filtering by platform and operation type
  • Quick actions to add new servers for each platform

Activity Tracking & Audit

Complete audit trail with 24+ activity types covering all operations across all platforms:

  • Advanced filtering (by type, date range, search text)
  • Export to CSV or JSON for compliance
  • Visual timeline with Material Design icons
  • Auto-refresh for real-time monitoring

Activity Log
Complete activity audit trail with filtering and export capabilities

Advanced Redis Support

Full CRUD operations for all 6 Redis data types:

  • Strings - View, add, update, and delete cached keys with TTL support
  • Lists - Push/pop elements, view all elements, manage list keys
  • Hashes - Set/get fields, view all fields, manage hash keys
  • Sets - Add/remove members, view set members
  • Sorted Sets - Add members with scores, view sorted members
  • Streams - Add entries with multiple fields, view stream entries

All operations support pagination for handling large datasets.

Redis Data Type Management
Managing Redis keys across different data types

RabbitMQ Exchange Management
RabbitMQ exchange and queue management

Multi-Environment Management

Tag servers by environment (Development, Staging, Production) with color-coded badges in the UI. This makes it easy to avoid accidentally modifying production resources and helps teams manage multi-environment workflows.

Technical Architecture

Backend: .NET 10.0 Modular Monolith

The backend uses a clean, modular architecture:

Nanuq.WebApi/          # FastEndpoints API
Nanuq.Kafka/           # Kafka integration
Nanuq.Redis/           # Redis integration
Nanuq.RabbitMQ/        # RabbitMQ integration
Nanuq.AWS/             # AWS SQS/SNS integration
Nanuq.Azure/           # Azure Service Bus integration
Nanuq.Security/        # AES-256 encryption service
Nanuq.EF/              # Entity Framework Core context
Nanuq.Sqlite/          # SQLite repositories
Nanuq.Common/          # Shared records and interfaces
Enter fullscreen mode Exit fullscreen mode

Key patterns:

  • FastEndpoints instead of traditional controllers for better performance
  • Repository pattern for data access abstraction
  • DbUp migrations for database schema management
  • Dependency injection throughout

Frontend: Vue 3 + Vuetify

The frontend leverages Vue 3 with Vuetify's Material Design components:

State management:

  • Separate Vuex modules for each platform (kafka.js, redis.js, aws.js, azure.js)
  • Centralized error handling with global notification system
  • Optimistic UI updates with rollback on errors

Database: SQLite with EF Core

SQLite provides zero-configuration persistence for all server configurations, credentials, and activity logs. DbUp migrations run automatically on startup, making schema updates seamless.

Getting Started

Docker (Recommended) 

# Pull and run both backend and frontend
docker-compose -f Docker/docker-compose.yml up -d

# Access the app
open http://localhost:8080
Enter fullscreen mode Exit fullscreen mode

Kubernetes

One-command deployment:

kubectl apply -f https://raw.githubusercontent.com/waelouf/Nanuq/main/K8s/nanuq-all-in-one.yaml

# Check deployment
kubectl get pods
kubectl get service nanuq-frontend
Enter fullscreen mode Exit fullscreen mode

Local Development

Backend:

cd src/services/Nanuq/Nanuq.WebApi
dotnet run  # Runs on http://localhost:5000
Enter fullscreen mode Exit fullscreen mode

Frontend:

cd src/app/nanuq-app
npm install
npm run serve  # Runs on http://localhost:8080
Enter fullscreen mode Exit fullscreen mode

Real-World Use Cases

Here are some scenarios where Nanuq shines:

1. Microservices Development
Developers working on microservices often need to inspect Kafka topics for event streams, check Redis caches for session data, and verify RabbitMQ queues for async tasks—all in one session.

2. Multi-Cloud Deployments
Teams deploying to both AWS and Azure can manage SQS queues and Azure Service Bus from the same interface, reducing context switching.

3. Environment Promotion
Tag servers as Dev/Staging/Production and easily compare configurations across environments before promoting changes.

4. Debugging Production Issues
Quickly check message counts, peek at queue contents, and identify bottlenecks without installing CLI tools or memorizing commands.

Performance Considerations

Pagination
All list operations support pagination to handle large datasets efficiently. Queue lists, topic lists, and message retrieval all use cursor-based or token-based pagination to prevent memory issues when dealing with hundreds or thousands of resources.

Caching Strategy
Frontend implements smart caching with selective invalidation:

  • Server lists cached until explicit refresh
  • Queue/topic details cached with 5-minute TTL
  • Message lists never cached (always fresh)

Connection Pooling
AWS and Azure SDK clients use connection pooling to minimize overhead and improve response times for consecutive operations.

Security Best Practices

What Nanuq Does:

  • Encrypts all credentials at rest (AES-256)
  • Never logs sensitive data (passwords, keys, tokens)
  • Uses HTTPS for all frontend-backend communication
  • Validates all user input on both frontend and backend

What You Should Do:

  • Use environment-specific credentials (don't share prod creds in dev)
  • Enable MFA on cloud accounts
  • Rotate credentials regularly
  • Review activity logs for unauthorized access
  • Deploy behind a VPN or restrict network access

Limitations and Future Roadmap

Current Limitations:

  • No built-in user authentication (single-user mode)
  • No role-based access control (RBAC)
  • Limited to Windows for DPAPI-based encryption (cross-platform encryption planned)

Roadmap (contributions welcome!):

  • Metrics and alerting (Prometheus integration)
  • Schema registry support for Kafka
  • More cloud platforms (Google Cloud Pub/Sub)
  • Dark mode UI theme

Contributing

Nanuq is open source and welcomes contributions:

Areas we'd love help with:

  • Cross-platform encryption (replace Windows DPAPI)
  • Unit and integration test coverage
  • Documentation improvements
  • Bug reports and feature requests

Check out the GitHub repository to get started.

Conclusion

Nanuq 2.0 represents a significant step forward in simplifying messaging and caching platform management. By consolidating five platforms into one interface with enterprise-grade security, we're reducing cognitive load for developers and making multi-platform workflows more efficient.

The project is built with modern .NET and Vue.js, follows clean architecture principles, and is designed to be easily extensible for additional platforms.

Try it out, and let me know what you think in the comments!

Links:

What messaging platforms are you managing in your projects? Would a unified interface like this help your workflow? Share your thoughts below!

Top comments (0)