Overall Microservice Interaction
This diagram illustrates the primary communication paths between the logical groups of microservices in the AXON platform. Click on any service group to learn more in the Deep Dive section.
Detailed Low-Level Application Design
Explore the technical implementation details, data flows, and architectural patterns used in the AXON platform.
Data Architecture
Primary Databases
- • PostgreSQL: User data, RBAC, execution history
- • MongoDB: Templates, manifests, collector data
- • DocumentDB: State management, metadata
Data Flow Patterns
- • Event-driven for state changes
- • CQRS for read/write separation
- • Saga pattern for distributed transactions
Security & Authentication
Authentication Flow
- • OIDC/SAML 2.0 integration
- • JWT token validation
- • Session management via HashiCorp Boundary
Authorization
- • OPA (Open Policy Agent) integration
- • Role-based access control
- • Resource-level permissions
API Design
REST API Patterns
- • Resource-oriented design
- • Consistent error handling
- • API versioning strategy
Communication
- • HTTP/2 for performance
- • gRPC for internal services
- • WebSocket for real-time updates
Technical Implementation Details
Service Communication Patterns
Synchronous: Direct HTTP calls for immediate responses
Asynchronous: Message queues for long-running operations
Event-Driven: Pub/Sub for state change notifications
Deployment & Infrastructure
Containerization: Docker containers with Kubernetes orchestration
Service Mesh: Istio for traffic management and observability
Monitoring: Prometheus metrics with Grafana dashboards
Logical Component Diagrams
Service Boundary Architecture
Frontend Layer: React.js SPA with TypeScript
API Gateway: Route traffic, authentication
Business Services: Core microservices
Data Layer: PostgreSQL, MongoDB, Redis
External Systems: ServiceNow, Cloud APIs
Data Flow Architecture
Request Flow: User → Frontend → API Gateway → Service
Authentication: IDP → RBAC → Service Authorization
Data Access: Service → Repository → Database
Event Flow: Service → Event Bus → Subscribers
Interface Documentation & API Contracts
REST API Contracts
Catalog Engine API
GET /api/v1/catalog/{persona} - Get catalog itemsGET /api/v1/catalog/{persona}/{category} - Filter by categoryPOST /api/v1/catalog/validate - Validate form dataExecution Service API
POST /api/v1/executions - Submit executionGET /api/v1/executions/{id} - Get execution statusPUT /api/v1/executions/{id}/cancel - Cancel executionService Interfaces
Internal Service Communication
gRPC://template-service:8080 - Template operationsgRPC://rbac-service:8080 - Authorization checksgRPC://manifest-service:8080 - Manifest operationsEvent Interfaces
Kafka://execution-events - Execution notificationsKafka://state-changes - State updatesKafka://audit-events - Audit loggingInventory Data Collection Architecture
Data Collection Layer
•
AWS Collector: EC2, IAM, Lambda, S3 inventory
•
Ali Cloud Collector: ECS, RAM, Function Compute
•
Azure Collector: VM, AD, Functions, Storage
•
On-Prem Collector: VMware, OpenStack, Bare Metal
Data Processing Pipeline
•
Data Ingestion: Scheduled collection (every 6 hours)
•
Data Transformation: Normalize to common schema
•
Data Enrichment: Add metadata and tags
•
Data Storage: MongoDB/DocumentDB with TTL
Data Utilization
•
Template Population: Dynamic form field values
•
Validation Rules: Resource existence checks
•
Cost Optimization: Unused resource identification
•
Compliance: Security posture assessment
Entity Relationship Diagrams & Data Flow
Core Entity Relationships
Users → Roles → Permissions
Templates → Manifests → Catalog Items
Executions → Job History → State Files
Collector Data → Inventory → Metadata
ServiceNow Tickets → Approvals → Changes
Data Flow Patterns
Real-time: User interactions, API calls
Batch: Data collection, reporting
Event-driven: State changes, notifications
Streaming: Log processing, metrics
Code Examples & Patterns
Service Discovery Pattern
// Service registration
@RestController
public class ServiceRegistry {
@PostMapping("/register")
public ResponseEntity<String> register(@RequestBody ServiceInfo info) {
// Register service with health checks
return ResponseEntity.ok("Registered");
}
}Circuit Breaker Pattern
@CircuitBreaker(name = "template-service")
public Template getTemplate(String id) {
return templateClient.getTemplate(id);
}
@FallbackMethod(fallbackMethod = "getTemplateFallback")
public Template getTemplateFallback(String id) {
return new Template(); // Default template
}Performance & Scalability Considerations
Caching Strategy
- • Redis for session storage
- • In-memory caching for templates
- • CDN for static assets
Load Balancing
- • Round-robin distribution
- • Health check integration
- • Auto-scaling policies
Database Optimization
- • Connection pooling
- • Query optimization
- • Read replicas
User Workflow: Execute a Catalog Item
Step through a typical user workflow to see how different microservices collaborate to fulfill a request. Use the buttons below to navigate the sequence.