navraj007in/infrastructure-generators

Infrastructure Generators

SDL-driven, deterministic generators that produce production-ready infrastructure configs. Same input always produces identical output.

Input: Compiled SDL document Output: YAML/JSON config files in artifacts/ directory

---

Docker Compose Generator

Generates a docker-compose.yml for local development with all services, databases, caches, queues, and search.

API: POST /api/sdl/docker-compose — { yaml: string }

Output files:

• artifacts/docker/docker-compose.yml — complete service orchestration
• artifacts/docker/.env — environment variable template

SDL sections used:

• architecture.projects.frontend[] / backend[] — service definitions
• data.primaryDatabase.type — database container (postgres, mysql, mongodb, sqlserver)
• data.secondaryDatabases[] — additional database containers
• data.cache.type — Redis container
• data.queues.provider — queue container (rabbitmq, kafka, redis)
• data.search.provider — search container (elasticsearch, meilisearch, typesense)
• auth.identityProvider — auth env vars (Auth0, Clerk, Cognito, Firebase)
• solution.name — container naming

What it includes per service:

• Multi-stage Dockerfile build context
• Framework-aware port assignment (Node=3000, FastAPI=8000, Go=8080, .NET=5000, Spring=8080, Rails=3000, Laravel=9000)
• Database URLs injected as env vars
• Redis URL if cache enabled
• Inter-service URLs using Docker service names
• Health checks with service_healthy depends_on
• Volume mounts for live reload
• Named volumes for data persistence
• Custom network

---

Kubernetes Generator

Generates production-ready K8s manifests with Deployments, Services, HPA, Ingress, ConfigMap, and Namespace.

API: POST /api/sdl/kubernetes — { yaml: string }

Output files (in artifacts/k8s/):

• namespace.yaml — namespace scoped to solution name
• configmap.yaml — shared config (NODE_ENV, DB_TYPE, AUTH_PROVIDER, REDIS_ENABLED)
• Per backend: backend-{name}-deployment.yaml, -service.yaml, -hpa.yaml
• Per frontend: frontend-{name}-deployment.yaml, -service.yaml
• ingress.yaml — HTTPS routing with cert-manager

SDL sections used:

• architecture.projects.backend[] / frontend[] — deployments and services
• nonFunctional.scaling.expectedUsersYear1 — replica count (>50k=5, >10k=3, else=2)
• solution.domain — ingress hostname (defaults to {slug}.example.com)
• nonFunctional.security.encryptionInTransit — TLS/cert-manager annotations
• data.primaryDatabase.type — ConfigMap DB_TYPE
• data.cache.type — ConfigMap REDIS_ENABLED
• auth.identityProvider — ConfigMap AUTH_PROVIDER

Resource limits:

| Tier | CPU Request | CPU Limit | Memory Request | Memory Limit | |------|------------|-----------|----------------|--------------| | Backend | 100m | 500m | 128Mi | 512Mi | | Frontend | 50m | 200m | 64Mi | 256Mi |

HPA: Scales on 70% CPU / 80% memory utilization, max replicas = min × 3

Probes: HTTP GET /health — readiness (5s initial, 10s period), liveness (15s initial, 20s period)

---

Monitoring Generator

Generates Prometheus scrape config, alert rules, and a Grafana dashboard JSON.

API: POST /api/sdl/monitoring — { yaml: string }

Output files (in artifacts/monitoring/):

• prometheus.yml — scrape config with per-service job definitions + node-exporter
• alert-rules.yml — alerting rules derived from NFRs
• grafana-dashboard.json — complete dashboard with per-service panels

SDL sections used:

• architecture.projects.backend[] / frontend[] — per-service scrape targets and panels
• nonFunctional.availability.target — error budget calculation for HighErrorRate threshold
• nonFunctional.performance.apiResponseTime — P95 latency alert threshold
• data.primaryDatabase.type — database connection pool alert (postgres/mysql/sqlserver only)
• integrations.monitoring.provider — metadata only

Alert rules generated:

| Alert | Trigger | Severity | |-------|---------|----------| | HighErrorRate | 5xx rate exceeds error budget | critical | | HighLatency | P95 > apiResponseTime target | warning | | ServiceDown_{name} | up{job} == 0 for 1m | critical | | HighCpuUsage | CPU > 85% for 10m | warning | | HighMemoryUsage | Memory > 90% for 5m | warning | | DatabaseConnectionPoolHigh | Pool > 80% for 5m | warning |

Grafana panels: Request rate, error rate, P95 latency, service uptime, per-service CPU/memory, per-service request duration percentiles (P50/P95/P99), database connections.

---

Nginx Generator

Generates a reverse proxy config with SSL, gzip, rate limiting, and security headers.

API: POST /api/sdl/nginx — { yaml: string }

Output files (in artifacts/nginx/):

• nginx.conf — complete reverse proxy configuration
• mime.types.conf — MIME type mappings
• docker-compose.nginx.yml — Docker Compose snippet to add nginx service

SDL sections used:

• architecture.projects.backend[] / frontend[] — upstream definitions
• solution.domain — server_name for HTTPS block
• Backend framework → port mapping (same as Docker Compose)

Features:

• HTTP → HTTPS redirect
• SSL/TLS config (TLSv1.2/1.3, session cache)
• Gzip compression (6 content types)
• Rate limiting: 30 req/s per IP, burst 50
• Security headers: X-Frame-Options, X-Content-Type-Options, X-XSS-Protection, Referrer-Policy
• WebSocket support (Upgrade/Connection headers)
• Per-backend API locations (single backend → /api, multiple → /api/{name})
• Frontend fallback at /
• Health check endpoint at /health

---

Deploy Diagram Generator

Generates a Mermaid deployment topology diagram from a deployment plan.

Not exposed via dedicated API route — used programmatically by the deploy-planner module.

Input: DeployDiagramInput (not an SDL document directly):

• strategy — deployment strategy name
• services[] — array of { name, platform, tier?, estimatedCost, config? }
• monthlyCost? — { min, max, typical }

Output: diagrams/deployment-topology.mmd — Mermaid flowchart

Features:

• Services grouped into subgraphs by platform (AWS, Azure, GCP, etc.)
• Categorized by role: frontend (cyan), backend (purple), data (amber)
• User → Frontend → Backend → Data flow edges
• Cost labels per service ($X/mo)
• Tier labels when specified

---

When to Use

• Docker Compose: After scaffolding — gives developers a one-command local dev setup
• Kubernetes: When deploying to K8s clusters — production-ready manifests
• Monitoring: When setting up observability — alerts tuned to SDL availability/performance targets
• Nginx: When adding a reverse proxy — SSL, routing, rate limiting preconfigured
• Deploy Diagram: When visualizing deployment topology — auto-generated from deploy planner output