---
title: 'Deploy Analog on AWS'
description: 'Deploy Analog applications on AWS using static hosting with S3 and CloudFront, or full-stack SSR with ECS Fargate and Application Load Balancer.'
---

import { Tabs, TabItem, LinkButton, Aside } from '@astrojs/starlight/components';

Deploy your [Analog](https://analogjs.org/) applications to AWS using Thunder patterns. This guide covers both static site generation (SSG) deployment and full-stack server-side rendering (SSR) options.

There are two deployment patterns available for Analog on AWS:

1. **Static Site Generation (SSG)** — Deploy static Analog sites using S3 and CloudFront with the [Single Page Application](/docs/patterns/s3-cloudfront) pattern
2. **Full Stack** — Deploy SSR Analog applications using ECS Fargate with the [Web Service](/docs/patterns/fargate-alb) pattern

<Aside type="note" title="Requirements">
- [AWS CDK](https://aws.amazon.com/cdk/) installed globally: `npm install -g aws-cdk`
- Node.js version 20 or higher
- [AWS credentials](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) configured
- AWS environment bootstrapped: `cdk bootstrap aws://your-account-id/us-east-1`
</Aside>


## Static Site Generation (SSG) Deployment
---

Deploy client-side Analog applications to S3 and CloudFront using the [CDK-SPA](https://github.com/thunder-so/cdk-spa) library. This pattern is ideal for static sites, blogs, and client-side applications.

### Create Project

<Tabs syncKey="package-manager">
  <TabItem label="npm" icon="seti:npm">
```sh
npm create analog my-analog-app
cd my-analog-app
```
  </TabItem>
  <TabItem label="pnpm" icon="pnpm">
```sh
pnpm create analog my-analog-app
cd my-analog-app
```
  </TabItem>
  <TabItem label="bun" icon="bun">
```sh
bun create analog my-analog-app
cd my-analog-app
```
  </TabItem>
</Tabs>

### Configure Analog for SSG

For details, refer to [Analog SSG](https://analogjs.org/docs/features/server/static-site-generation) documentation.

```ts title="vite.config.ts"
import { defineConfig } from 'vite';
import analog from '@analogjs/platform';

// https://vitejs.dev/config/
export default defineConfig(({ mode }) => ({
  plugins: [
    analog({
      static: true
    }),
  ],
}));
```

### Install Dependencies and Setup Stack

<Tabs syncKey="package-manager">
  <TabItem label="npm" icon="seti:npm">
```sh
npm i tsx @thunderso/cdk-spa --save-dev
```
  </TabItem>
  <TabItem label="pnpm" icon="pnpm">
```sh
pnpm add -D tsx @thunderso/cdk-spa
```
  </TabItem>
  <TabItem label="bun" icon="bun">
```sh
bun add -d tsx @thunderso/cdk-spa
```
  </TabItem>
</Tabs>

```ts title="stack/index.ts"
import { Cdk, SPAStack, type SPAProps } from "@thunderso/cdk-spa";

const myApp: SPAProps = {
  env: {
    account: 'your-account-id',
    region: 'us-east-1'
  },
  application: 'your-application-id',
  service: 'your-service-id',
  environment: 'production',

  rootDir: '', // e.g. 'frontend/' for monorepos
  outputDir: 'dist/',
};

new SPAStack(
  new Cdk.App(), 
  `${myApp.application}-${myApp.service}-${myApp.environment}-stack`, 
  myApp
);
```

### Environment Variables and Secrets for Build

Configure build-time environment variables using the `buildProps` configuration:

```ts title="stack/index.ts"
const myApp: SPAProps = {
  // ... other props
  
  buildProps: {
    environment: [
      { VITE_API_URL: 'https://api.example.com' },
      { VITE_ANALYTICS_ID: 'UA-XXXXXX' }
    ],
    secrets: [
      { key: 'API_KEY', resource: '/my-app/API_KEY' },
    ],
  },
};
```

### Deploy

Build and deploy your SPA:

<Tabs syncKey="package-manager">
  <TabItem label="npm" icon="seti:npm">
```sh
npm run build
npx cdk deploy --all --app="npx tsx stack/index.ts"
```
  </TabItem>
  <TabItem label="pnpm" icon="pnpm">
```sh
pnpm run build
pnpm exec cdk deploy --all --app="pnpm exec tsx stack/index.ts"
```
  </TabItem>
  <TabItem label="bun" icon="bun">
```sh
bun run build
npx cdk deploy --all --app="bunx tsx stack/index.ts"
```
  </TabItem>
</Tabs>

After deployment, you'll receive a **CloudFront URL** to access your application.

For complete documentation, see the [CDK-SPA README](https://github.com/thunder-so/cdk-spa).

## Full Stack Deployment
---

Deploy server-side rendered Analog applications using ECS Fargate and Application Load Balancer with the [CDK-WebService](https://github.com/thunder-so/cdk-webservice) library.

### Configure Analog for SSR

Analog enables SSR by default. Refer to [Analog SSR](https://analogjs.org/docs/features/server/server-side-rendering) documentation.

### Install Dependencies and Setup Stack

<Tabs syncKey="package-manager">
  <TabItem label="npm" icon="seti:npm">
```sh
npm i tsx @thunderso/cdk-webservice --save-dev
```
  </TabItem>
  <TabItem label="pnpm" icon="pnpm">
```sh
pnpm add -D tsx @thunderso/cdk-webservice
```
  </TabItem>
  <TabItem label="bun" icon="bun">
```sh
bun add -d tsx @thunderso/cdk-webservice
```
  </TabItem>
</Tabs>

```ts title="stack/index.ts"
import { Cdk, WebServiceStack, type WebServiceProps } from "@thunderso/cdk-webservice";

const svcProps: WebServiceProps = {
  env: {
    account: 'your-account-id',
    region: 'us-west-2'
  },
  application: 'your-application-id',
  service: 'your-service-id',
  environment: 'production',

  rootDir: '', // e.g. 'app/' for monorepos
};

new WebServiceStack(
  new Cdk.App(), 
  `${svcProps.application}-${svcProps.service}-${svcProps.environment}-stack`, 
  svcProps
);
```

### Build Settings Using Nixpacks

Configure automatic containerization with Nixpacks:

```ts title="stack/index.ts"
const svcProps: WebServiceProps = {
  // ... other props
  
  buildProps: {
    buildSystem: 'Nixpacks',
    installcmd: 'bun install',
    buildcmd: 'bun run build',
    startcmd: 'bun start',
  },
};
```

### Build Settings Using Docker Container

Alternatively, use a custom Dockerfile:

```dockerfile title="Dockerfile"
FROM public.ecr.aws/docker/library/alpine

# Install Bun
RUN curl -fsSL https://bun.sh/install | bash

# Update PATH for bun
ENV PATH="/root/.bun/bin:$PATH"

# Copy code, install and build
WORKDIR /app
COPY . .
RUN bun install
RUN bun run build

EXPOSE 5173
CMD ["bun", "start"]
```

```ts title="stack/index.ts"
const svcProps: WebServiceProps = {
  // ... other props
  
  serviceProps: {
    dockerFile: 'Dockerfile',
    port: 5173,
  },
};
```

### Environment Variables and Secrets for SSR

Configure runtime environment variables and secrets:

```ts title="stack/index.ts"
const svcProps: WebServiceProps = {
  // ... other props
  
  serviceProps: {
    variables: [
      { NODE_ENV: 'production' },
      { PUBLIC_API_URL: 'https://api.example.com' }
    ],
    secrets: [
      { 
        key: 'DATABASE_URL', 
        resource: 'arn:aws:secretsmanager:us-west-2:123456789012:secret:/my-app/DATABASE_URL-abc123' 
      },
    ],
  },
};
```

### Deploy

Build and deploy your containerized application:

<Tabs syncKey="package-manager">
  <TabItem label="npm" icon="seti:npm">
```sh
npm run build
npx cdk deploy --all --app="npx tsx stack/index.ts"
```
  </TabItem>
  <TabItem label="pnpm" icon="pnpm">
```sh
pnpm run build
pnpm exec cdk deploy --all --app="pnpm exec tsx stack/index.ts"
```
  </TabItem>
  <TabItem label="bun" icon="bun">
```sh
bun run build
npx cdk deploy --all --app="bunx tsx stack/index.ts"
```
  </TabItem>
</Tabs>

After deployment, you'll receive an **Application Load Balancer URL** to access your SSR application.

For complete documentation, see the [CDK-WebService README](https://github.com/thunder-so/cdk-webservice).