🚀 MicroserviceKit - .NET 8 Microservice Template Generator

🚀 Complete toolkit for generating production-ready .NET 8 microservices with DDD, CQRS, Clean Architecture, Event-Driven Architecture, and comprehensive infrastructure.

✨ Features

🏗️ Clean Architecture - Domain, Application, Infrastructure, API layers
📦 Domain-Driven Design - Aggregates, Entities, Value Objects, Domain Events
⚡ CQRS Pattern - Command Query Responsibility Segregation with MassTransit
🔄 Event-Driven Architecture - RabbitMQ, MassTransit, Domain Events
🗄️ Multi-Database Support - PostgreSQL (write), MongoDB (read), Redis (cache)
🔗 External Services Integration - HTTP clients with Polly resilience
🧪 Comprehensive Testing - Unit, Integration, E2E with TestContainers
🐳 Docker & Kubernetes - Production-ready containerization with Dockerfile, docker-compose.yml, Makefile
📊 Monitoring & Health Checks - Built-in observability
🔐 Security - JWT authentication, OAuth2, RBAC
🌐 API Gateway - Centralized routing and authentication

🆕 What's New in v0.4.5

✅ Complete Template Library - All 16 microservice templates now included in CLI package
🎯 Enhanced Discovery - microkit list command with filtering and detailed views
📋 Template Details - microkit describe command for comprehensive template information
🚀 Production Ready - Templates include Docker, Kubernetes, testing, and monitoring
🔧 CLI Improvements - Better error handling and user experience
📦 NuGet Distribution - Templates embedded in NuGet package for global availability

🚀 Quick Start

Install the CLI tool

# Install latest version (v0.4.5)
dotnet tool install -g MicroserviceKit
# Or update existing installation
dotnet tool update -g MicroserviceKit

Generate your first microservice

# Interactive mode (recommended for beginners)
microkit generate MyService --interactive
# Quick start with enterprise template
microkit generate ArticleService --template cqrs-event-sourcing
# With custom aggregates and external services
microkit generate MyService --template cqrs-event-sourcing --aggregates Article Comment --external-services ImageService VideoService

Explore available templates

# List all 16 available templates
microkit list
# List by category
microkit list --category service-types
microkit list --category levels
# Get detailed template information
microkit describe cqrs-event-sourcing.json

📋 Available Templates

16 production-ready templates across 4 categories:

🏷️ Enterprise Service Types

Perfect for production microservices with complex business requirements:

`cqrs-event-sourcing.json` ⭐ Most Popular

Use for: Services with complex business rules, audit trail requirements, event-driven architecture
Complexity: Enterprise (25 minutes)
Features: CQRS, Event Sourcing, Domain Events, Aggregate Root, PostgreSQL
Perfect for: Article management, Order processing, Financial transactions

`bpc-workflow.json`

Use for: Business process orchestration, workflow management, external system integration
Complexity: Enterprise (30 minutes)
Features: Workflow Engine, Saga Pattern, External Integrations, State Machine, Hangfire
Perfect for: Payment processing, Document approval workflows, Multi-step business processes

`event-store.json`

Use for: Centralized event storage, event replay, audit logs
Complexity: Enterprise (20 minutes)
Features: Event Store, Event Sourcing, Projections, Event Replay
Perfect for: Event sourcing infrastructure, Audit systems, Event analytics

`read-model.json`

Use for: High-performance read operations, reporting, data projections
Complexity: Medium (15 minutes)
Features: CQRS Read Side, MongoDB, Projections, Redis Cache, Event Handlers
Perfect for: Reporting services, Search APIs, Data analytics

`identity-auth.json`

Use for: User authentication, authorization, multi-tenant security
Complexity: Enterprise (25 minutes)
Features: OAuth2, JWT, RBAC, Multi-Auth, Identity Server
Perfect for: Identity provider, User management, API security

`api-gateway.json`

Use for: Centralized API management, routing, cross-cutting concerns
Complexity: Enterprise (20 minutes)
Features: API Gateway, Routing, Rate Limiting, Circuit Breaker, Ocelot
Perfect for: Microservices entry point, API aggregation, Security gateway

`multi-tenant.json`

Use for: SaaS applications, tenant isolation, configuration per tenant
Complexity: Enterprise (20 minutes)
Features: Multi-tenancy, Tenant Isolation, Configuration per Tenant, Domain Routing
Perfect for: SaaS platforms, Multi-client systems, Tenant-specific features

`legacy-adapter.json`

Use for: Integration with legacy systems, data synchronization
Complexity: Medium (15 minutes)
Features: Adapter Pattern, Legacy Integration, Data Sync, Anti-corruption Layer
Perfect for: Legacy system integration, Data migration, System modernization

`search-indexing.json`

Use for: Full-text search, content indexing, search analytics
Complexity: Medium (15 minutes)
Features: Elasticsearch, Search Indexing, Event-driven, Full-text Search
Perfect for: Content search, Product catalogs, Document search

`cqrs-simple.json`

Use for: CQRS without Event Sourcing, simpler business logic
Complexity: Medium (15 minutes)
Features: CQRS, Clean Architecture, PostgreSQL, Redis Cache
Perfect for: CRUD-heavy services, Simple business logic, Standard applications

🏗️ Architecture Levels

Choose based on your project complexity:

`standard-service.json` 📊 Balanced

Use for: Standard business applications, moderate complexity
Complexity: Medium (10 minutes)
Features: Clean Architecture, CQRS, SQLite, JWT Auth
Perfect for: Business applications, Standard APIs, Moderate complexity

`enterprise-service.json` 🏢 Full Featured

Use for: Enterprise applications, all patterns included
Complexity: Complex (20 minutes)
Features: DDD, CQRS, Event Sourcing, Microservices Patterns, Docker, Kubernetes
Perfect for: Large enterprises, Complex domains, Full-scale microservices

🏗️ Generated Architecture

Every generated service includes:

MyService/
├── src/
│ ├── Domain/ # Domain layer (DDD)
│ │ ├── Aggregates/ # Aggregate roots with business logic
│ │ ├── Entities/ # Domain entities
│ │ ├── ValueObjects/ # Immutable value objects
│ │ ├── Events/ # Domain events
│ │ └── Repositories/ # Repository interfaces
│ ├── Application/ # Application layer (CQRS)
│ │ ├── Commands/ # Command handlers (write operations)
│ │ ├── Queries/ # Query handlers (read operations)
│ │ ├── DTOs/ # Data transfer objects
│ │ └── Behaviors/ # Cross-cutting concerns
│ ├── Infrastructure/ # Infrastructure layer
│ │ ├── Persistence/ # EF Core, MongoDB, Redis
│ │ ├── ExternalServices/ # HTTP clients with Polly
│ │ ├── Messaging/ # MassTransit + RabbitMQ
│ │ └── Configuration/ # Dependency injection
│ └── Api/ # API layer
│ ├── Controllers/ # REST API controllers
│ ├── Middleware/ # Custom middleware
│ └── Extensions/ # Service registration
├── tests/
│ ├── Unit/ # Unit tests with xUnit
│ ├── Integration/ # Integration tests with TestContainers
│ └── EndToEnd/ # E2E tests
├── Dockerfile # Multi-stage Docker build
├── docker-compose.yml # Complete development environment
├── Makefile # Development commands
├── k8s/ # Kubernetes manifests
└── docs/ # Auto-generated documentation

🛠️ CLI Commands

🚀 Generate Commands

# Interactive mode (recommended)
microkit generate MyService --interactive
# Quick generation with template
microkit generate ArticleService --template cqrs-event-sourcing
# Custom aggregates
microkit generate MyService --template cqrs-event-sourcing --aggregates Article Comment User
# External services integration
microkit generate MyService --template cqrs-event-sourcing --external-services ImageService VideoService NotificationService
# Full customization
microkit generate MyService --template cqrs-event-sourcing \
--aggregates Article Comment \
--external-services ImageService VideoService \
--database postgresql \
--output ./services/ArticleService

📋 Discovery Commands

# List all 16 available templates
microkit list
# List by category (4 categories available)
microkit list --category service-types # 10 enterprise templates
microkit list --category levels # 3 architecture levels
microkit list --category examples # 1 complete example
microkit list --category configs # 2 base configurations# Filter by complexity
microkit list --complexity enterprise # Advanced templates
microkit list --complexity medium # Balanced templates
microkit list --complexity simple # Quick start templates# Detailed view with features and usage info
microkit list --detailed
# Output in different formats
microkit list --format table # Default table view
microkit list --format json # JSON output
microkit list --format markdown # Markdown format# Get comprehensive template information
microkit describe cqrs-event-sourcing.json # Full template details
microkit describe api-gateway.json --format json # JSON output
microkit describe standard-service.json # Architecture level info

🔧 Template Customization

Example: Article Service Configuration

{
"templateType": "cqrs-event-sourcing",
"microserviceName": "ArticleService",
"namespace": "Company.ArticleService",
"domain": {
"aggregates": [
{
"name": "Article",
"properties": [
{ "name": "Title", "type": "string", "isRequired": true },
{ "name": "Content", "type": "string", "isRequired": true },
{ "name": "Status", "type": "ArticleStatus", "isRequired": true }
],
"operations": ["Create", "Update", "Publish", "Archive"]
}
]
},
"features": {
"database": {
"writeModel": { "provider": "postgresql" },
"readModel": { "provider": "mongodb" }
},
"messaging": { "enabled": true, "provider": "rabbitmq" },
"externalServices": {
"enabled": true,
"services": [
{
"name": "ImageService",
"baseUrl": "https://api.images.com",
"operations": ["Upload", "Process", "Delete"]
}
]
}
},
"deployment": {
"docker": { "enabled": true },
"kubernetes": { "enabled": true }
}
}

🧪 Testing & Development

Generated Development Environment

Every service includes a complete development setup:

# Start development environment
make dev-setup
# Run the service
make run
# Run tests
make test# Build Docker image
make docker-build
# Run with Docker
make docker-run
# Clean up
make clean

Testing with TestContainers

# Unit tests
dotnet test tests/Unit/
# Integration tests with real databases
dotnet test tests/Integration/
# End-to-end tests
dotnet test tests/EndToEnd/
# All tests
make test

🐳 Docker & Kubernetes

Complete Containerization

Every generated service includes:

Multi-stage Dockerfile - Optimized for production
docker-compose.yml - Complete development environment with PostgreSQL, MongoDB, Redis, RabbitMQ
Kubernetes manifests - Production-ready K8s deployment
Health checks - Liveness and readiness probes
Makefile - All development commands

# Development with Docker Compose
docker-compose up -d
# Build production image
docker build -t myservice:latest .# Deploy to Kubernetes
kubectl apply -f k8s/

📊 Monitoring & Observability

Built-in Monitoring

Health Checks - /health, /health/ready, /health/live
Metrics - ASP.NET Core built-in metrics
Structured Logging - Serilog with correlation IDs
Distributed Tracing - OpenTelemetry ready

# Health endpoints
curl http://localhost:5000/health
curl http://localhost:5000/health/ready
curl http://localhost:5000/health/live
# Metrics endpoint
curl http://localhost:5000/metrics

🔐 Security

Authentication & Authorization

# JWT for internal services
curl -H "Authorization: Bearer <jwt-token>" \
http://localhost:5000/api/articles
# OAuth2 for external applications
curl -H "Authorization: Bearer <oauth-token>" \
http://localhost:5000/api/articles

🌟 Real-World Examples

Headless CMS Architecture

# Article management service
microkit generate ArticleService --template cqrs-event-sourcing --aggregates Article ArticleBlock
# Page management service
microkit generate PageService --template cqrs-event-sourcing --aggregates Page PageLayout
# Content read service
microkit generate ContentReadService --template read-model --aggregates ArticleProjection PageProjection
# Search service
microkit generate SearchService --template search-indexing
# Identity service
microkit generate IdentityService --template identity-auth --aggregates User Role Permission
# API Gateway
microkit generate ApiGateway --template api-gateway

E-commerce Platform

# Order management
microkit generate OrderService --template cqrs-event-sourcing --aggregates Order OrderItem
# Product catalog
microkit generate ProductService --template cqrs-simple --aggregates Product Category
# Inventory management
microkit generate InventoryService --template cqrs-event-sourcing --aggregates Inventory
# Payment processing
microkit generate PaymentService --template bpc-workflow --aggregates Payment PaymentMethod
# Search service
microkit generate SearchService --template search-indexing

📚 Documentation

🤝 Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests
Submit a pull request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

Built with ❤️ for the .NET community

Name		Name	Last commit message	Last commit date
.cursor/rules		.cursor/rules
docs		docs
examples		examples
src		src
templates		templates
tests/CLI.Tests		tests/CLI.Tests
.dockerignore		.dockerignore
.gitignore		.gitignore
CLI_REFACTORING_PLAN.md		CLI_REFACTORING_PLAN.md
GETTING_STARTED.md		GETTING_STARTED.md
LICENSE		LICENSE
MICROSERVICES_CONCEPT.md		MICROSERVICES_CONCEPT.md
Makefile		Makefile
README.md		README.md
docs.md		docs.md

Latest commit

History

Folders and files

Repository files navigation

🚀 MicroserviceKit - .NET 8 Microservice Template Generator

✨ Features

🆕 What's New in v0.4.5

🚀 Quick Start

Install the CLI tool

Generate your first microservice

Explore available templates

📋 Available Templates

🏷️ Enterprise Service Types

cqrs-event-sourcing.json ⭐ Most Popular

bpc-workflow.json

event-store.json

read-model.json

identity-auth.json

api-gateway.json

multi-tenant.json

legacy-adapter.json

search-indexing.json

cqrs-simple.json