Fjall Docs — deploy AWS infrastructure into your own account

Overview

ComputeFactory is Fjall’s factory for compute resources. One call covers three compute types: ECS containers, Lambda functions, and standalone EC2 instances. ComputeFactory.build(id, props) returns a builder that app.addCompute() invokes. The type field is the required discriminant, so props are checked against the matching overload at compile time.

Basic Usage

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

const app = App.getApp("acme");

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        cpu: 256,
        memoryLimitMiB: 512,
      },
    ],
  }),
);

Omitting containers gives the service one implicit container on the application’s default ECR image, with no port and no load-balancer attachment. That is the normal shape for a Fjall-scaffolded application.

Compute Types

ECS (Elastic Container Service)

Deploy containerised services with three capacity providers.

Fargate (recommended)

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        cpu: 512,
        memoryLimitMiB: 1024,
        desiredCount: 2,
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

Fargate Spot (cost savings)

app.addCompute(
  ComputeFactory.build("WorkerCompute", {
    type: "ecs",
    services: [
      {
        name: "worker",
        serviceType: "worker",
        capacityProvider: "FARGATE_SPOT",
        cpu: 256,
        memoryLimitMiB: 512,
      },
    ],
  }),
);

EC2-backed ECS

app.addCompute(
  ComputeFactory.build("DashboardCompute", {
    type: "ecs",
    services: [
      {
        name: "dashboard",
        capacityProvider: "EC2",
        // EC2 services size the container via ec2Config. The service-level
        // cpu/memoryLimitMiB fields are Fargate-only.
        ec2Config: {
          instanceType: "t4g.small",
          memoryLimitMiB: 512,
        },
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

Lambda Functions

Code deployment requires code. Import Code from the package root, which re-exports it from aws-cdk-lib/aws-lambda.

import { Code, ComputeFactory } from "@fjall/components-infrastructure";

app.addCompute(
  ComputeFactory.build("ThumbnailFunction", {
    type: "lambda",
    deployment: "code",
    code: Code.fromAsset("./dist/thumbnail"),
    handler: "index.handler",
    memorySize: 512,
    timeout: 30,
  }),
);

Container deployment builds from a Dockerfile:

app.addCompute(
  ComputeFactory.build("ReportFunction", {
    type: "lambda",
    deployment: "container",
    // fjall deploy builds this and pushes it to the app's default registry.
    docker: { path: "report.Dockerfile" },
    memorySize: 1024,
  }),
);

Or track an image you build and push yourself:

app.addCompute(
  ComputeFactory.build("ReportFunction", {
    type: "lambda",
    deployment: "container",
    ecrRepository: app.getDefaultContainerRegistry(),
    memorySize: 1024,
  }),
);

ecrRepository is optional. With docker set it defaults to the application’s shared container registry, the same repository ECS services push into. Supply it explicitly only when you manage the image out of band.

EC2 Instances

Deploy an Auto Scaling group of virtual machines:

app.addCompute(
  ComputeFactory.build("BuildRunner", {
    type: "ec2",
    instanceType: "t4g.micro",
    minCapacity: 1,
    maxCapacity: 3,
  }),
);

The group is reached over Session Manager unless you set sshAccess, which opens port 22 to the ranges you name and nothing else:

app.addCompute(
  ComputeFactory.build("Bastion", {
    type: "ec2",
    instanceType: "t4g.nano",
    sshAccess: {
      allowedIpCidrs: ["203.0.113.4/32"],
      public: true,
    },
  }),
);

allowedIpCidrs is the only required field. Omit keyName to have a key pair created, and public to keep the group in private subnets. "0.0.0.0/0" deploys with a synth warning. See EC2 Instance for the full contract and what synth rejects.

ECS Reference

Compute-Root Parameters

Parameter	Type	Description	Default
`type`	`"ecs"`	Required discriminant	Required
`services`	`EcsServiceConfig[]`	Service configurations	Required
`cluster`	`object`	Cluster-level configuration	ALB with defaults
`vpc`	`IVpc`	VPC to deploy into	App default VPC
`ecrRepository`	`Repository \| RepositoryImage`	Default image source for every service	App default registry
`docker`	`object`	Cluster-level build config used when no service sets `docker`	-
`appName`	`string`	SSM secrets namespace root	`App.getName()`
`alertsTopic`	`ITopic \| string`	SNS topic (or ARN) for alarm notifications	-
`containerInsights`	`true`	CloudWatch Container Insights. Also arms `RunningTaskCount` alarms and adds cost	off
`taskStopWatchdog`	`false`	Set `false` to disable the abnormal-task-stop forensic log and churn alarm	on
`applicationId`	`string`	Application id used for alarm tagging	Application name

Service Configuration

Each entry in the services array:

Parameter	Type	Description	Default
`name`	`string`	Service name, unique within the cluster	Required
`capacityProvider`	`"FARGATE" \| "FARGATE_SPOT" \| "EC2"`	Compute capacity	Required
`containers`	`array`	Container definitions	One implicit container
`serviceType`	`"web" \| "worker"`	Service intent. A `worker` rejects container ports and routing at synth	`"web"`
`image`	`string \| Repository`	Image for the first container without an explicit image	App default registry
`cpu`	`number`	CPU units (256-4096). Fargate only, rejected at synth on EC2	`256`
`memoryLimitMiB`	`number`	Memory in MiB (512-30720). Fargate only, rejected at synth on EC2 unless it mirrors `ec2Config.memoryLimitMiB`	`512`
`desiredCount`	`number`	Number of tasks	`2`
`scaling`	`object \| false`	Auto-scaling. Omit for defaults, `false` to disable	Enabled with defaults
`routing`	`object \| object[]`	ALB routing rules	`/*` for a single service
`connections`	`ConnectionSpec[]`	Resources this service connects to	-
`remoteConnections`	`RemoteConnectionSpec[]`	Cross-application resources reachable over VPC peering	-
`docker`	`object`	Dockerfile build config: `{ path, context?, target?, buildArgs?, buildSecrets? }`	Cluster `docker`
`ec2Config`	`object`	EC2 capacity configuration	-
`ssmSecretsPath`	`string`	SSM Parameter Store path prefix	`/<app>/<cluster>/<service>`
`taskRoleInlinePolicies`	`object`	Extra inline IAM policies on the task role	-
`taskRoleManagedPolicies`	`IManagedPolicy[]`	Extra managed policies on the task role	-
`alarms`	`object \| false`	Per-service alarm thresholds, `false` to disable	CPU, memory, tasks, ALB 5xx and p99
`logAlarms`	`array`	Log-pattern metric filters and alarms. Needs `alertsTopic`	-
`migrations`	`object`	Init-container, lifecycle-hook, or post-deploy migrations	-
`awaitMigrationsFrom`	`string`	Name of a service whose hook migrations must finish first	-
`schemaGate`	`boolean \| object`	Schema-version gate for connected migrated databases	`true`

The service-level cpu and memoryLimitMiB fields are Fargate only. On an EC2 service, size the container with ec2Config.memoryLimitMiB. Setting either on EC2 capacity is rejected at synth, naming the field and the service.

Container Configuration

Each entry in the containers array:

Parameter	Type	Description	Default
`name`	`string`	Container name. Required when another container’s `dependsOn` names it	`<service>Container[n]`
`image`	`string`	ECR repository name or public image URL	App default registry
`port`	`number`	Container port. The first container with a port receives ALB traffic	none (no ALB attachment)
`portMappings`	`PortMapping[]`	Multi-port containers. Mutually exclusive with `port`	-
`environment`	`object`	Environment variables	`{}`
`secrets`	`string[]`	Secret names read from the service’s SSM namespace	`[]`
`secretsImport`	`object`	Secrets imported from Secrets Manager or another CDK resource	`{}`
`command`	`string[]`	Container command	Image `CMD`
`entryPoint`	`string[]`	Container entry point	Image `ENTRYPOINT`
`essential`	`boolean`	Stopping this container stops the task	`true`
`healthCheck`	`object`	`{ command, interval?, timeout?, retries?, startPeriod? }`	none
`dependsOn`	`array`	`[{ container, condition }]` start ordering within the task	-
`volumes`	`array`	Host-bind volumes mounted into this container	-
`stopTimeout`	`number`	Seconds between SIGTERM and SIGKILL (1-120)	`30`

No container health check is injected by default. Without one, and without an ALB target group, ECS treats a container as healthy the moment it is RUNNING, so a post-start exit is invisible to the deployment circuit breaker. Declare a healthCheck on workers whose liveness should gate deployments.

Routing Configuration

Parameter	Type	Description	Default
`path`	`string`	URL path pattern	`"/*"`
`host`	`string`	Host header match	-
`priority`	`number`	Rule priority (1-50000). Lower wins	Auto
`healthCheckPath`	`string`	Target-group health check endpoint	`"/"`

routing also accepts an array, so one service can answer several rules through one target group:

routing: [
  { path: "/api/v2/*", priority: 50 },
  { path: "/*", priority: 200 },
];

Scaling Configuration

Auto-scaling is on by default. Omitting scaling gives minCapacity = desiredCount and maxCapacity = max(desiredCount + 1, 3), so a service left at the default desiredCount: 2 scales between two and three tasks. Set scaling: false to opt out.

Parameter	Type	Description	Default
`minCapacity`	`number`	Minimum tasks	`desiredCount`
`maxCapacity`	`number`	Maximum tasks	`max(desiredCount + 1, 3)`
`scalingType`	`ScalingType`	`CPU`, `MEMORY`, or `QUEUE`	`ScalingType.CPU`
`queueScaling`	`object`	Required when `scalingType` is `ScalingType.QUEUE`	-

scalingType takes the ScalingType enum, not a string:

import { ScalingType } from "@fjall/components-infrastructure";

scaling: {
  minCapacity: 2,
  maxCapacity: 10,
  scalingType: ScalingType.CPU,
}

Queue-backed workers

ScalingType.QUEUE is the only mode that scales to zero. CPU and memory target-tracking publish no datapoint at zero tasks, so they cannot wake an idle service. Queue scaling alarms on SQS backlog instead, which publishes every minute regardless of running tasks.

import {
  MessagingFactory,
  ScalingType,
} from "@fjall/components-infrastructure";

const jobQueue = app.addMessaging(
  MessagingFactory.build("JobQueue", { type: "queue" }),
);

app.addCompute(
  ComputeFactory.build("WorkerCompute", {
    type: "ecs",
    services: [
      {
        name: "worker",
        serviceType: "worker",
        capacityProvider: "FARGATE",
        desiredCount: 0,
        // The RunningTaskCount alarm would sit in ALARM at an idle steady
        // state. A 0 floor disables only that alarm.
        alarms: { runningTasksMinimum: 0 },
        scaling: {
          scalingType: ScalingType.QUEUE,
          minCapacity: 0,
          maxCapacity: 5,
          queueScaling: { queues: [jobQueue.getQueue()] },
        },
      },
    ],
  }),
);

`queueScaling` field	Type	Description	Default
`queues`	`IQueue[]`	Queues whose combined backlog drives desired count. At least one	Required
`includeInFlight`	`boolean`	Count received-but-not-deleted messages as backlog	`true`
`cooldown`	`Duration`	Cooldown after a scale action	5 minutes

Cluster Configuration

Cluster settings control the shared ALB for every service in the cluster.

Parameter	Type	Description	Default
`loadBalancer`	`"public" \| "internal" \| false`	Load balancer type	`"public"`
`directAccess`	`boolean`	Direct container access with no ALB, host network mode	`false`
`domain`	`string`	Shorthand for `domainConfig.domainName`	-
`domainConfig`	`object`	Domain, zone source, certificate, and DNS routing	-
`securityGroup`	`ISecurityGroup`	Externally-supplied security group for EC2 capacity	Created
`scheduledTasks`	`array`	Cron or rate-driven ECS tasks registered on the cluster	-

Load balancer options

// Public load balancer (default), internet-facing.
app.addCompute(
  ComputeFactory.build("WebCompute", {
    type: "ecs",
    cluster: { loadBalancer: "public" },
    services: [
      {
        name: "web",
        capacityProvider: "FARGATE",
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

// Internal load balancer, reachable inside the VPC only.
app.addCompute(
  ComputeFactory.build("InternalApiCompute", {
    type: "ecs",
    cluster: { loadBalancer: "internal" },
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

// No load balancer, for background workers.
app.addCompute(
  ComputeFactory.build("WorkerCompute", {
    type: "ecs",
    cluster: { loadBalancer: false },
    services: [
      { name: "worker", serviceType: "worker", capacityProvider: "FARGATE" },
    ],
  }),
);

Custom Domains

domainConfig needs a domainName plus a zone source. Fjall never creates a hosted zone inside an application stack, because such a zone is undelegated: certificate validation hangs until CloudFormation rolls back, and destroying the stack deletes the zone.

A domain or domainConfig.domainName with no resolvable zone source fails at synth with an error naming both cures. There is no certificateArn, hostedZoneId, or hostedZoneName field on domainConfig.

Parameter	Type	Description	Default
`domainName`	`string`	Domain served by the cluster ALB	Required
`managedDomain`	`object`	Zone and certificate from a Fjall-managed domain stack	Injected
`hostedZone`	`HostedZone`	Explicitly imported zone via `HostedZoneFactory.import(...)`	-
`certificate`	`Certificate`	Bring-your-own ACM certificate	Minted
`routingPolicy`	`object`	Route 53 routing policy, for example `{ type: "latency", region }`	Plain alias
`apexRecord`	`"alias" \| "none"`	`"none"` keeps listeners, certificates and redirect records but withholds the cluster’s own apex A record	`"alias"`
`redirectHosts`	`string[]`	Hostnames that permanently redirect to `domainName` at the ALB	-
`additionalCertificates`	`array`	Extra SNI certificates on the HTTPS listener	-

Fjall-managed domain

This is the normal path. Run fjall domain deploy example.com once, then name the domain. The CLI injects the zone id and certificate ARN as CDK context at deploy time, so no literal zone id lives in your infrastructure file.

app.addCompute(
  ComputeFactory.build("WebCompute", {
    type: "ecs",
    cluster: {
      domainConfig: {
        domainName: "api.example.com",
        routingPolicy: { type: "latency", region: "eu-west-1" },
      },
    },
    services: [
      {
        name: "web",
        capacityProvider: "FARGATE",
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

Bring your own hosted zone

Import a zone you already own. HostedZoneFactory.import takes a Fjall stack, the zone id, and the zone name.

import {
  ComputeFactory,
  HostedZoneFactory,
} from "@fjall/components-infrastructure";

app.addCompute(
  ComputeFactory.build("WebCompute", {
    type: "ecs",
    cluster: {
      domainConfig: {
        domainName: "api.example.com",
        hostedZone: HostedZoneFactory.import(
          app.getDefaultComputeStack(),
          "Z1234567890ABC",
          "example.com",
        ),
      },
    },
    services: [
      {
        name: "web",
        capacityProvider: "FARGATE",
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

For a bare CDK synth in the same account and region, managedDomain can instead import the domain stack’s CloudFormation exports:

domainConfig: {
  domainName: "api.example.com",
  managedDomain: {
    zoneName: "example.com",
    hostedZoneIdExport: "ExampleComHostedZoneId",
    certificateArnExport: "ExampleComCertificateArn",
  },
}

EC2 Capacity Configuration

ec2Config applies when a service sets capacityProvider: "EC2".

Parameter	Type	Description	Default
`slot`	`string`	Capacity slot, lowercase kebab. Services sharing a slot share one Auto Scaling group	`"primary"`
`identityAnchor`	`string`	Explicit identity-anchor pin for a deployed pre-6.0 group	Slot-derived
`instanceType`	`string`	EC2 instance type	`"t4g.small"`
`amiHardwareType`	`"ARM" \| "STANDARD"`	AMI hardware type	Inferred from `instanceType`
`memoryLimitMiB`	`number`	Container hard memory limit, the only memory knob for EC2	`1024`
`minCapacity`	`number`	Minimum EC2 instances	`2`
`maxCapacity`	`number`	Maximum EC2 instances	`3`
`desiredCapacity`	`number`	Initial instance count	-
`warmPool`	`object`	`{ minSize?, reuseOnScaleIn? }` for 10-15s starts	-
`machineImage`	`IMachineImage`	Custom AMI	ECS-optimised AL2023
`userData`	`UserData`	Launch-template user data	Empty
`blockDevices`	`BlockDevice[]`	EBS attachments	-
`instanceMonitoring`	`Monitoring`	Detailed monitoring on the launch template	`Monitoring.BASIC`
`associatePublicIpAddress`	`boolean`	Give instances a public IP	-
`availabilityZones`	`string[]`	Pin the group to specific AZs	All VPC AZs
`persistentDataVolume`	`object`	Standalone EBS volume that re-attaches across refreshes. Makes the slot a singleton	-
`updatePolicy`	`object`	Auto Scaling group update policy	Instance refresh
`tags`	`object`	Tags applied to the group and every launched instance	-

slot is the sharing key. Two services declaring the same slot, including two services that both omit it and land on "primary", share one Auto Scaling group built from the first service’s ec2Config. Every other ec2Config field must then agree across those services. A mismatch is rejected at synth naming both services and each differing field, because the second service’s value would otherwise be discarded silently.

// Rejected at synth: same slot, different minCapacity.
{ name: "api",     capacityProvider: "EC2", ec2Config: { instanceType: "t4g.medium", minCapacity: 2 } },
{ name: "reports", capacityProvider: "EC2", ec2Config: { instanceType: "t4g.medium", minCapacity: 5 } }

Two cures, meaning different things:

Align the values when the services were always meant to share capacity. The group already runs on the first service’s numbers, so copying those onto the second changes nothing. Copying the second service’s numbers onto the first resizes a running group.
Give one service its own slot when they were meant to scale independently. That creates a second Auto Scaling group, which is a real cost change.

machineImage, userData and blockDevices compare on presence only, set against unset, because CDK gives them no cheap structural identity. Two services that each supply an equivalent userData are accepted.

Memory fit

Synth rejects an EC2 service whose container hard-memory limits sum to at least the instance type’s nominal memory, whether instanceType was set or defaulted. Registered memory always sits below nominal memory because the ECS agent and the OS reserve some, so such a task can never be placed on any instance count. The stack deploys cleanly at desiredCount: 0 and then wedges at the first scale-up. t4g.micro registers roughly 896 MiB, below the 1024 MiB default container limit. Explicit t4g.micro stays supported, which is what the free-tier Tinkerer preset pins with memoryLimitMiB: 400. Keep the container limits comfortably under 896 MiB total.

app.addCompute(
  ComputeFactory.build("DashboardCompute", {
    type: "ecs",
    services: [
      {
        name: "dashboard",
        capacityProvider: "EC2",
        ec2Config: {
          instanceType: "t4g.large",
          minCapacity: 2,
          maxCapacity: 10,
          // The container hard limit for an EC2 service. The service-level
          // cpu/memoryLimitMiB fields are Fargate-only and rejected here.
          memoryLimitMiB: 1024,
        },
        containers: [{ port: 3000 }],
      },
    ],
  }),
);

Lambda Reference

Parameter	Type	Description	Default
`type`	`"lambda"`	Required discriminant	Required
`deployment`	`"code" \| "container"`	Deployment variant	Required
`code`	`Code`	Function code. Required for `deployment: "code"`	Required (code)
`handler`	`string`	Handler entry point (code deployment)	`"index.handler"`
`runtime`	`Runtime`	Lambda runtime. A runtime AWS has deprecated fails synth	`Runtime.NODEJS_24_X`
`ecrRepository`	`Repository \| RepositoryImage`	Image source (container deployment)	App default registry
`docker`	`object`	Dockerfile built and pushed by `fjall deploy` (container deployment)	-
`image`	`string`	Shared build and tag key for functions running the same image	Construct id
`entrypoint`	`string[]`	Override the image `ENTRYPOINT`	Image value
`cmd`	`string[]`	Override the image `CMD`, the handler Lambda invokes	Image value
`workingDirectory`	`string`	Override the image `WORKDIR`	Image value
`architecture`	`Architecture`	`Architecture.ARM_64` or `Architecture.X86_64`	`Architecture.ARM_64`
`timeout`	`number`	Timeout in seconds	`3`
`memorySize`	`number`	Memory in MB	`128`
`ephemeralStorageSize`	`number`	Ephemeral storage in MiB (512-10240)	`512`
`environment`	`object`	Environment variables	`{}`
`secrets`	`string[]`	Secret names read from the function’s SSM namespace	`[]`
`ssmSecretsPath`	`string`	SSM path prefix for secrets	`/<app>/lambda/<fn>`
`secretsImport`	`object`	Secrets imported from Secrets Manager or another CDK resource	`{}`
`connections`	`ConnectionSpec[]`	Resources this function connects to	-
`vpc`	`IVpc`	VPC to attach the function to	App VPC when connections are set
`inlinePolicy`	`PolicyStatement[]`	Extra IAM policy statements	-
`functionUrl`	`object \| false`	Function URL. Omit or `false` to disable, `{}` for IAM auth	Disabled
`description`	`string`	Function description	-

architecture takes the Architecture enum from aws-cdk-lib/aws-lambda. For a container deployment with docker set it also selects the platform fjall deploy builds for, so set it here rather than passing --platform to Docker.

Function URLs

`functionUrl` field	Type	Description	Default
`authType`	`FunctionUrlAuthType`	`AWS_IAM` or `NONE`	`FunctionUrlAuthType.AWS_IAM`
`cors`	`object`	CORS configuration	-
`invokeMode`	`InvokeMode`	`RESPONSE_STREAM` for Lambda response streaming	`InvokeMode.BUFFERED`

import {
  Code,
  ComputeFactory,
  FunctionUrlAuthType,
  HttpMethod,
} from "@fjall/components-infrastructure";
import { Duration } from "aws-cdk-lib";

app.addCompute(
  ComputeFactory.build("PublicApiFunction", {
    type: "lambda",
    deployment: "code",
    code: Code.fromAsset("./dist/public-api"),
    handler: "index.handler",
    functionUrl: {
      authType: FunctionUrlAuthType.NONE,
      cors: {
        allowedOrigins: ["*"],
        allowedMethods: [HttpMethod.GET, HttpMethod.POST],
        allowedHeaders: ["Content-Type"],
        maxAge: Duration.hours(24),
      },
    },
  }),
);

EC2 Reference

Parameter	Type	Description	Default
`type`	`"ec2"`	Required discriminant	Required
`instanceType`	`string`	EC2 instance type	`"t4g.micro"`
`sshAccess`	`Ec2SshAccessProps`	SSH access: `allowedIpCidrs` (required), `keyName`, `public`. See EC2 Instance	Off, Session Manager only
`userData`	`UserData`	Instance startup script	-
`machineImage`	`IMachineImage`	AMI to use	Amazon Linux 2023
`minCapacity`	`number`	Minimum instances in the Auto Scaling group	`1`
`maxCapacity`	`number`	Maximum instances in the Auto Scaling group	`1`
`spotCapacityPercentage`	`number`	Percentage of capacity on Spot (0-100). Up to about 90% cheaper on the Spot portion, interruptible	`0`
`vpc`	`IVpc`	VPC to deploy into	App default VPC

Connections

connections wires a service or function to databases, buckets, queues, and tables. Fjall creates the security-group rules for connectable resources and the IAM grants for the rest, scoped to that service alone.

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        containers: [{ port: 3000 }],
        connections: [
          database,
          { resource: uploads, access: "write" },
          { resource: jobQueue, access: "consume" },
        ],
      },
    ],
  }),
);

Read connection details straight from the resource constructs for environment variables and secrets:

const database = app.addDatabase(
  DatabaseFactory.build("AcmeDatabase", {
    type: "Aurora",
    databaseName: "acme",
  }),
);

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        connections: [database],
        containers: [
          {
            port: 3000,
            environment: {
              DATABASE_HOST: database.getHostEndpoint(),
              DATABASE_NAME: database.getDatabaseName(),
            },
            secretsImport: {
              DATABASE_PASSWORD: database
                .getCredentials()
                .getImport("password"),
            },
          },
        ],
      },
    ],
  }),
);

Multi-Container Service

import { ScalingType } from "@fjall/components-infrastructure";

app.addCompute(
  ComputeFactory.build("WebCompute", {
    type: "ecs",
    services: [
      {
        name: "web",
        capacityProvider: "FARGATE",
        cpu: 512,
        memoryLimitMiB: 1024,
        containers: [
          {
            name: "app",
            port: 3000,
            environment: { NODE_ENV: "production" },
          },
          {
            name: "nginx",
            image: "nginx:alpine",
            port: 80,
          },
        ],
        routing: {
          path: "/*",
          healthCheckPath: "/health",
        },
        scaling: {
          minCapacity: 2,
          maxCapacity: 10,
          scalingType: ScalingType.CPU,
        },
      },
    ],
  }),
);

Cost Optimisation

Development and batch workloads:

// Fargate Spot for a dev service.
app.addCompute(
  ComputeFactory.build("DevWebCompute", {
    type: "ecs",
    services: [
      {
        name: "web",
        capacityProvider: "FARGATE_SPOT",
        cpu: 256,
        memoryLimitMiB: 512,
        desiredCount: 1,
        scaling: false,
      },
    ],
  }),
);

// Lambda for batch jobs.
app.addCompute(
  ComputeFactory.build("BatchFunction", {
    type: "lambda",
    deployment: "code",
    code: Code.fromAsset("./dist/batch"),
    handler: "batch.handler",
    timeout: 900,
    memorySize: 1024,
  }),
);

Production right-sizing:

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        cpu: 512,
        memoryLimitMiB: 1024,
        desiredCount: 2,
        containers: [{ port: 3000 }],
        scaling: {
          minCapacity: 2,
          maxCapacity: 10,
        },
      },
    ],
  }),
);

Three levers carry most of the saving:

Lever	Applies to	Effect
`capacityProvider: "FARGATE_SPOT"`	ECS services	Up to about 70% off, interruptible
`spotCapacityPercentage`	EC2 compute	Up to about 90% off the Spot portion, interruptible
`ScalingType.QUEUE` with `desiredCount: 0`	ECS workers	Idle at zero tasks, wake on queue backlog

Next Steps

ECS Cluster Resources

Configure ECS clusters for advanced workloads.

Lambda Function Resources

Configure Lambda functions at the resource layer.

Database Factory

Provision Aurora, RDS, DynamoDB, and ClickHouse databases.

Standard Pattern

Compose full applications from these factories.

Factory Patterns

Application Patterns

Architecture Patterns

Compute Factory

Overview

Basic Usage

Compute Types

ECS (Elastic Container Service)

Fargate (recommended)

Fargate Spot (cost savings)

EC2-backed ECS

Lambda Functions

EC2 Instances

ECS Reference

Compute-Root Parameters

Service Configuration

Container Configuration

Routing Configuration

Scaling Configuration

Queue-backed workers

Cluster Configuration

Load balancer options

Custom Domains

Fjall-managed domain

Bring your own hosted zone

EC2 Capacity Configuration

Memory fit

Lambda Reference

Function URLs

EC2 Reference

Connections

Multi-Container Service

Cost Optimisation

Next Steps

ECS Cluster Resources

Lambda Function Resources

Database Factory

Standard Pattern

​Overview

​Basic Usage

​Compute Types

​ECS (Elastic Container Service)

​Fargate (recommended)

​Fargate Spot (cost savings)

​EC2-backed ECS

​Lambda Functions

​EC2 Instances

​ECS Reference

​Compute-Root Parameters

​Service Configuration

​Container Configuration

​Routing Configuration

​Scaling Configuration

​Queue-backed workers

​Cluster Configuration

​Load balancer options

​Custom Domains

​Fjall-managed domain

​Bring your own hosted zone

​EC2 Capacity Configuration

​Services that share an Auto Scaling group

​Memory fit

​Lambda Reference

​Function URLs

​EC2 Reference

​Connections

​Multi-Container Service

​Cost Optimisation

​Next Steps

ECS Cluster Resources

Lambda Function Resources

Database Factory

Standard Pattern

Overview

Basic Usage

Compute Types

ECS (Elastic Container Service)

Fargate (recommended)

Fargate Spot (cost savings)

EC2-backed ECS

Lambda Functions

EC2 Instances

ECS Reference

Compute-Root Parameters

Service Configuration

Container Configuration

Routing Configuration

Scaling Configuration

Queue-backed workers

Cluster Configuration

Load balancer options

Custom Domains

Fjall-managed domain

Bring your own hosted zone

EC2 Capacity Configuration

Services that share an Auto Scaling group

Memory fit

Lambda Reference

Function URLs

EC2 Reference

Connections

Multi-Container Service

Cost Optimisation

Next Steps