> ## Documentation Index
> Fetch the complete documentation index at: https://ravion-b90c0359-mintlify-710044b6.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# How to deploy Astro to AWS

> Deploy an Astro static site to your AWS account with S3 and CloudFront using Ravion, including build pipelines, custom domains, HTTPS, and CDN caching.

Deploy your Astro static build to an S3 bucket behind CloudFront.

## Prerequisites

* A Git repository containing your application and its production build command.
* A Ravion account with your AWS account connected. Start free at [Ravion signup](https://app.ravion.com/signup).
* The Ravion CLI installed and authenticated. See [CLI installation](/cli/installation).

The examples use `my-org/my-app` as a placeholder. Replace it with your repository before applying the config.

<Prompt description="Set up this Astro app for Ravion static or SSR hosting." icon="sparkles" actions={["copy", "cursor"]}>
  1. Before any other action, read and follow [https://www.ravion.com/docs/start-here#agent-workflow](https://www.ravion.com/docs/start-here#agent-workflow) as the mandatory agent workflow.
  2. Use [https://www.ravion.com/docs/deploy/aws/astro](https://www.ravion.com/docs/deploy/aws/astro) as the framework-specific source of truth.
  3. Confirm this repository contains the Astro app and locate its root in any monorepo.
  4. Inspect `package.json` and `astro.config.*` to detect the real build command, adapter, output mode, server entry, and port. Preserve `PUBLIC_` for browser-visible variables.
  5. Generate `ravion.yaml` using the static `rvn-aws-static` modules or SSR `rvn-aws-network` + `rvn-ecs-cluster` + `rvn-ecs-web` modules, with real repo and AWS values substituted. Bind SSR to `0.0.0.0`.
  6. Ask the user for missing AWS account IDs, repository slugs, database credentials, or adapter output before proceeding; do not guess.
</Prompt>

## Configure the deployment

The bucket and distribution stay in your AWS account, and Ravion versions each deployment.

This example uses [Railpack](https://railpack.com) for the build. Use `build_source: dockerfile` instead when you need a custom Dockerfile.

For a static Astro site, `astro build` writes to `dist`. Set `routing` to `filesystem` so generated paths resolve to their files.

```yaml ravion.yaml theme={null}
project:
  givenId: astro-site
  name: Astro site
environments:
  - givenId: production
    name: Production
    moduleInstances:
      - givenId: static-site
        name: Astro site
        type: rvn-aws-static
        version: 1.0.0
        input:
          aws_account_id: ravion-prod
          aws_region: us-east-1
          name: astro-site-production
          routing: filesystem
          build_source: railpack
          source_repo: my-org/my-astro-site
          railpack_build_cmd: npm run build
```

## Apply the config

<Steps>
  <Step title="Create the project">
    ```bash theme={null}
    ravion project create --given-id astro-site --name "Astro site"
    ```
  </Step>

  <Step title="Preview and apply">
    ```bash theme={null}
    ravion project config apply astro-site --file ravion.yaml --dry-run
    ravion project config apply astro-site --file ravion.yaml
    ```
  </Step>
</Steps>

Astro variables prefixed with `PUBLIC_` are exposed to browser code. Add them to `build_environment_variables` when they are required at build time. Keep server-only values out of a static build.

## Custom domain

Use the CloudFront distribution hostname from the module outputs, then follow [custom domains](/guides/custom-domains) to add an ACM certificate and DNS record.

## Astro SSR on ECS

For on-demand rendering, install `@astrojs/node`, set `output: "server"`, and configure standalone mode. Astro writes the server entry to `dist/server/entry.mjs`; run it with Node on port `4321`.

```yaml ravion.yaml theme={null}
project:
  givenId: astro-ssr
  name: Astro SSR app
environments:
  - givenId: production
    name: Production
    moduleInstances:
      - givenId: network
        name: Network
        type: rvn-aws-network
        version: 1.0.0
        input:
          aws_account_id: ravion-prod
          aws_region: us-east-1
          name: astro-ssr-production
      - givenId: cluster
        name: ECS cluster
        type: rvn-ecs-cluster
        version: 1.0.0
        input:
          network:
            moduleGivenIdRef: network
          name: astro-ssr-production
      - givenId: web
        name: Astro SSR web service
        type: rvn-ecs-web
        version: 1.0.0
        input:
          cluster:
            moduleGivenIdRef: cluster
          name: astro-ssr-production-web
          build_source: railpack
          source_repo: my-org/my-astro-app
          railpack_build_cmd: npm run build
          railpack_start_cmd: node ./dist/server/entry.mjs
          container_port: 4321
          fargate_size:
            vcpu: 0.5
            memory_gb: 1
```

Set `HOST=0.0.0.0` and `PORT=4321` in the runtime environment. Use the ECS service's Application Load Balancer hostname for your custom domain.

## Next steps

<CardGroup cols={2}>
  <Card title="Custom domains" icon="globe" href="/guides/custom-domains">
    Point a domain at your deployed service and manage its certificate.
  </Card>

  <Card title="Project config" icon="file-code" href="/config-as-code/project-config-file">
    Preview and apply Ravion configuration from source control.
  </Card>

  <Card title="Pipelines" icon="arrow-progress" href="/config-as-code/pipeline-config-file">
    Add approvals, migrations, and deployment automation.
  </Card>

  <Card title="Logs and metrics" icon="chart-line" href="/modules/logs">
    Inspect deploy output and production health in Ravion.
  </Card>
</CardGroup>