Architecture Overview

Architecture Overview

Constellation is a cloud-native telemetry platform built for high-throughput satellite constellation operations.

System Architecture

                                    ┌─────────────────────────────────────┐
                                    │           AWS Cloud                  │
┌───────────────┐                   │                                     │
│   Operators   │                   │  ┌─────────────────────────────┐   │
│               │                   │  │     Route53 DNS             │   │
│  ┌─────────┐  │                   │  │  api.constellation-io.com   │   │
│  │   CLI   │──┼───────────────────┼─▶│  dev.constellation-io.com   │   │
│  └─────────┘  │                   │  └──────────────┬──────────────┘   │
│               │                   │                 │                   │
│  ┌─────────┐  │                   │  ┌──────────────▼──────────────┐   │
│  │ Dashboard│──┼───────────────────┼─▶│   Application Load Balancer │   │
│  └─────────┘  │    HTTPS/443      │  │   (SSL termination)         │   │
│               │                   │  └──────────────┬──────────────┘   │
└───────────────┘                   │                 │                   │
                                    │  ┌──────────────▼──────────────┐   │
                                    │  │      ECS Fargate            │   │
                                    │  │  ┌────────────────────────┐ │   │
                                    │  │  │     FastAPI App        │ │   │
                                    │  │  │  ┌─────────────────┐   │ │   │
                                    │  │  │  │ Telemetry API   │   │ │   │
                                    │  │  │  │ Predictions API │   │ │   │
                                    │  │  │  │ Topology API    │   │ │   │
                                    │  │  │  └─────────────────┘   │ │   │
                                    │  │  └────────────────────────┘ │   │
                                    │  └──────────────┬──────────────┘   │
                                    │                 │                   │
                                    │     ┌───────────┴───────────┐       │
                                    │     ▼                       ▼       │
                                    │  ┌────────────┐   ┌──────────────┐ │
                                    │  │   Redis    │   │ TimescaleDB  │ │
                                    │  │ (Streams)  │   │ (Telemetry)  │ │
                                    │  └────────────┘   └──────────────┘ │
                                    │                                     │
                                    └─────────────────────────────────────┘

Components

API Gateway (ALB)

• AWS Application Load Balancer with SSL termination
• Routes traffic to ECS Fargate tasks
• Health checks on /health endpoint
• Blue/green deployment support via CodeDeploy

Compute (ECS Fargate)

• FastAPI application running in Docker containers
• Auto-scaling from 1 to 20 tasks based on CPU/memory
• No public IP - all traffic through ALB
• JWT authentication middleware

Message Queue (Redis Streams)

• ElastiCache Redis for high-throughput message passing
• Telemetry published to telemetry stream
• Supports consumer groups for parallel processing
• ~10x throughput improvement with pipelining

Storage (TimescaleDB)

• PostgreSQL with TimescaleDB extension
• Time-series optimized for telemetry data
• Automatic partitioning by time
• Efficient queries for recent data windows

Authentication (Cognito)

• AWS Cognito user pools for operator management
• OAuth2/OIDC for CLI and dashboard
• Optional MFA support
• Custom attributes: operator_id, organization

Data Flow

Telemetry Ingestion

1. Operator posts telemetry via CLI or API
2. ALB routes request to ECS task
3. FastAPI validates JWT and payload
4. Telemetry published to Redis stream
5. Graph engine updated with latest metrics
6. Background worker persists to TimescaleDB

Operator → ALB → ECS/FastAPI → Redis Streams → TimescaleDB
                      ↓
                 Graph Engine

Batch Processing

For high-throughput scenarios:

1. Batch of up to 1,000 telemetry points received
2. Redis pipeline used for atomic batch publish
3. Graph updates throttled (every 15 seconds)
4. Background tasks handle persistence

Prediction Queries

1. Client requests predictions for a node
2. API retrieves 10-minute telemetry history
3. LSTM models generate forecasts (1, 3, 5 min)
4. Results cached in Redis (60s TTL)

Network Architecture

VPC Layout

VPC (10.0.0.0/16)
├── Public Subnets
│   └── ALB (internet-facing)
│
└── Private Subnets
    ├── ECS Tasks (no public IP)
    ├── Redis (ElastiCache)
    └── TimescaleDB (RDS)

Security Groups

Component	Inbound	Outbound
ALB	80, 443 from 0.0.0.0/0	All
ECS	8000 from ALB only	All
Redis	6379 from ECS only	All
RDS	5432 from ECS only	All

Deployment

Environments

Environment	Domain	Deployment
Development	api-dev.constellation-io.com	Rolling
Staging	api-staging.constellation-io.com	Rolling
Production	api.constellation-io.com	Blue/Green

Blue/Green Deployments

Production uses CodeDeploy for zero-downtime deployments:

1. New version deployed to “green” target group
2. Test traffic routed to port 8443 for validation
3. 30-minute manual approval window
4. Traffic switched from blue to green
5. Old tasks terminated after 5-minute grace period

Infrastructure as Code

All infrastructure managed with Terraform:

terraform/
├── main.tf              # Root module
├── variables.tf         # Input variables
├── outputs.tf           # Output values
├── modules/
│   ├── networking/      # VPC, subnets, security groups
│   ├── ecs/             # Fargate cluster and services
│   ├── alb/             # Load balancer
│   ├── redis/           # ElastiCache
│   ├── rds/             # TimescaleDB
│   ├── dns/             # Route53
│   ├── cognito/         # User authentication
│   └── static-site/     # S3 + CloudFront for website
└── environments/
    ├── dev/
    ├── staging/
    └── prod/

Performance Targets

Metric	Target	Current
Throughput	100,000 msg/sec	~50,000 msg/sec
Latency (P99)	< 100ms	~150ms
Availability	99.9%	99.9%

Scaling

Horizontal Scaling

• ECS auto-scales based on CPU/memory utilization
• Redis cluster mode available for higher throughput
• Read replicas for TimescaleDB (future)

Vertical Scaling

• ECS task CPU/memory configurable per environment
• Redis node types: cache.t3.micro to cache.r6g.xlarge
• RDS instance classes: db.t3.micro to db.r6g.2xlarge