Resilient Pattern

fjall create app --type resilient

┌─────────────────┐
│   CloudFront    │ (Optional CDN)
└────────┬────────┘
         |
┌────────┴────────┐
│      ALB        │ (Multi-AZ)
└────────┬────────┘
         |
┌────────┴────────┐
│  ECS Fargate    │ (4-20 tasks, Multi-AZ)
│  1024 CPU       │
│  2048 MiB       │
└────────┬────────┘
         |
┌────────┴────────┐
│    Aurora       │ (Multi-AZ, automatic failover)
└─────────────────┘

#!/usr/bin/env node

import {
  App,
  DatabaseFactory,
  ComputeFactory,
  getConfig,
} from "@fjall/components-infrastructure";

const appName = "critical";
const app = App.getApp(appName);

app.addTags({
  "fjall:costAllocation:owner": "engineering",
});

const criticalStorage = app.addDatabase(
  DatabaseFactory.build("CriticalStorage", {
    type: "Aurora",
    databaseName: "CriticalDatabase",
  }),
);

app.addCompute(
  ComputeFactory.build("CriticalCompute", {
    type: "ecs",
    ecrRepository: app.getDefaultContainerRegistry(),
    services: [
      {
        name: "app",
        capacityProvider: "FARGATE",
        cpu: 1024,
        memoryLimitMiB: 2048,
        desiredCount: 4,
        scaling: {
          minCapacity: 4,
          maxCapacity: 20,
        },
        containers: [
          {
            port: 3000,
            environment: {
              ENVIRONMENT: getConfig().environment,
              DATABASE_HOST: criticalStorage.getHostEndpoint(),
              DATABASE_PORT: `${criticalStorage.getHostPort()}`,
              DATABASE_NAME: criticalStorage.getDatabaseName(),
            },
            secretsImport: {
              DATABASE_PASSWORD: criticalStorage
                .getCredentials()
                .getImport("password"),
            },
          },
        ],
      },
    ],
  }),
);

// CPU-based scaling
const scaling = service.autoScaleTaskCount({
  minCapacity: 4,
  maxCapacity: 20,
});

scaling.scaleOnCpuUtilization("CpuScaling", {
  targetUtilizationPercent: 70,
  scaleInCooldown: Duration.seconds(60),
  scaleOutCooldown: Duration.seconds(60),
});

// Request-based scaling
scaling.scaleOnRequestCount("RequestScaling", {
  requestsPerTarget: 1000,
  targetGroup: alb.targetGroup,
});

// Application alarms
new cloudwatch.Alarm(this, "HighErrorRate", {
  metric: alb.metricHttpCodeTarget5XXCount(),
  threshold: 10,
  evaluationPeriods: 2,
});

// Database alarms
new cloudwatch.Alarm(this, "DatabaseCPU", {
  metric: database.metricCPUUtilization(),
  threshold: 80,
  evaluationPeriods: 3,
});