@spree/docs 0.1.0

package/dist/developer/deployment/aws.md

@@ -0,0 +1,335 @@
+---
+title: Amazon Web Services (AWS)
+description: Learn how to deploy your Spree application on Amazon Web Services (AWS).
+---
+
+Amazon Web Services offers reliable, scalable, and inexpensive cloud computing services. AWS is also one of the most popular choices for hosting a Spree application. 
+
+We recommend using AWS ECS Fargate to host your Spree application via [Docker image](/developer/deployment/docker).
+
+## Required AWS services
+
+To fully run your Spree application on AWS, you will need the following services:
+
+| Service | Description |
+|---------|-------------|
+| [AWS ECS Fargate](https://aws.amazon.com/fargate/) | Amazon Elastic Container Service (ECS) is a fully managed container orchestration service that allows you to run and scale containerized applications without managing the underlying infrastructure. |
+| [AWS RDS](https://aws.amazon.com/rds/) | Amazon Relational Database Service makes it easy to set up, operate, and scale a relational database in the cloud. Spree works great with multiple databases: [Amazon Aurora both MySQL and PostgreSQL variants](https://aws.amazon.com/rds/aurora/), [RDS PostgreSQL](https://aws.amazon.com/rds/postgresql/), [RDS MySQL](https://aws.amazon.com/rds/mysql/) and [RDS MariaDB](https://aws.amazon.com/rds/mariadb/) |
+| [AWS ElastiCache](https://aws.amazon.com/elasticache/redis/?nc=sn&loc=2&dn=1) | Valkey or Redis instance for background jobs (Sidekiq), [caching](/developer/deployment/caching), and Action Cable. |
+| [AWS S3](https://aws.amazon.com/s3/) | Object storage service to store and read your uploaded files such as Product images, etc. [More information](/developer/deployment/assets#aws-s3). |
+| [AWS CloudFront](https://aws.amazon.com/cloudfront/) | Fast content delivery network CDN to speed up your asset images/stylesheets/javascript delivery. This will greatly enhance your application responsiveness. |
+| [AWS Route 53](https://aws.amazon.com/route53/) | Domain name system (DNS) service to manage your domain names and DNS records. |
+| [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/) | AWS Certificate Manager is a service that provides you with SSL/TLS certificates that you can use to secure your application. Spree in production works only with HTTPS. |
+| [AWS ECR](https://aws.amazon.com/ecr/) | Amazon Elastic Container Registry is a fully managed Docker container registry that makes it easy to store, manage, and deploy Docker container images. |
+
+## Docker Image
+
+You can use the [official Docker image](/developer/deployment/docker) (`ghcr.io/spree/spree`) directly, or build your own from your Rails application's Dockerfile.
+
+To build and deploy a custom image to AWS ECR via GitHub Actions:
+
+```yaml
+name: Deploy to AWS Fargate
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  AWS_REGION: us-east-1
+  ECR_REPOSITORY: spree-starter
+  ECS_SERVICE_WEB: spree-web
+  ECS_SERVICE_WORKER: spree-worker
+  ECS_CLUSTER: spree-cluster
+  
+jobs:
+  build:
+    name: Build and Push to ECR
+    runs-on: ubuntu-latest
+    
+    outputs:
+      image: ${{ steps.build-image.outputs.image }}
+      image-tag: ${{ steps.build-image.outputs.image-tag }}
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ env.AWS_REGION }}
+    
+    - name: Login to Amazon ECR
+      id: login-ecr
+      uses: aws-actions/amazon-ecr-login@v2
+    
+    - name: Build, tag, and push image to Amazon ECR
+      id: build-image
+      env:
+        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+        IMAGE_TAG: ${{ github.sha }}
+      run: |
+        # Build a docker container and push it to ECR
+        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+        echo "image=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG" >> $GITHUB_OUTPUT
+        echo "image-tag=$IMAGE_TAG" >> $GITHUB_OUTPUT
+  
+  deploy-web:
+    name: Deploy Web Service
+    runs-on: ubuntu-latest
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ env.AWS_REGION }}
+    
+    - name: Fill in the new image ID in the Amazon ECS task definition
+      id: task-def-web
+      uses: aws-actions/amazon-ecs-render-task-definition@v1
+      env:
+        ECR_REGISTRY: ${{ needs.build.outputs.image }}
+        IMAGE_TAG: ${{ needs.build.outputs.image-tag }}
+        AWS_ACCOUNT_ID: ${{ secrets.AWS_ACCOUNT_ID }}
+      with:
+        task-definition: .aws/web-task-definition.json
+        container-name: web
+        image: ${{ needs.build.outputs.image }}
+    
+    - name: Deploy Amazon ECS task definition for web
+      uses: aws-actions/amazon-ecs-deploy-task-definition@v1
+      with:
+        task-definition: ${{ steps.task-def-web.outputs.task-definition }}
+        service: ${{ env.ECS_SERVICE_WEB }}
+        cluster: ${{ env.ECS_CLUSTER }}
+        wait-for-service-stability: true
+  
+  deploy-worker:
+    name: Deploy Worker Service
+    runs-on: ubuntu-latest
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ env.AWS_REGION }}
+    
+    - name: Fill in the new image ID in the Amazon ECS task definition
+      id: task-def-worker
+      uses: aws-actions/amazon-ecs-render-task-definition@v1
+      env:
+        ECR_REGISTRY: ${{ needs.build.outputs.image }}
+        IMAGE_TAG: ${{ needs.build.outputs.image-tag }}
+        AWS_ACCOUNT_ID: ${{ secrets.AWS_ACCOUNT_ID }}
+      with:
+        task-definition: .aws/worker-task-definition.json
+        container-name: worker
+        image: ${{ needs.build.outputs.image }}
+    
+    - name: Deploy Amazon ECS task definition for worker
+      uses: aws-actions/amazon-ecs-deploy-task-definition@v1
+      with:
+        task-definition: ${{ steps.task-def-worker.outputs.task-definition }}
+        service: ${{ env.ECS_SERVICE_WORKER }}
+        cluster: ${{ env.ECS_CLUSTER }}
+        wait-for-service-stability: true
+
+  migrate:
+    name: Run Database Migrations
+    runs-on: ubuntu-latest
+    needs: [build, deploy-web]
+    if: github.ref == 'refs/heads/main'
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ env.AWS_REGION }}
+    
+    - name: Run database migrations
+      run: |
+        aws ecs run-task \
+          --cluster ${{ env.ECS_CLUSTER }} \
+          --task-definition spree-web \
+          --overrides '{
+            "containerOverrides": [{
+              "name": "web",
+              "command": ["bundle", "exec", "rails", "db:migrate"]
+            }]
+          }' \
+          --launch-type FARGATE \
+          --network-configuration '{
+            "awsvpcConfiguration": {
+              "subnets": ["'${{ secrets.SUBNET_ID_1 }}'", "'${{ secrets.SUBNET_ID_2 }}'"],
+              "securityGroups": ["'${{ secrets.SECURITY_GROUP_ID }}'"],
+              "assignPublicIp": "ENABLED"
+            }
+          }'
+```
+
+This action requires secrets to be set in your GitHub repository. You can find the full list of secrets in the [AWS ECS Deploy Task Definition](https://github.com/aws-actions/amazon-ecs-deploy-task-definition) GitHub Actions repository.
+
+| Secret | Description |
+|--------|-------------|
+| `AWS_ACCESS_KEY_ID` | AWS access key ID |
+| `AWS_SECRET_ACCESS_KEY` | AWS secret access key |
+| `AWS_ACCOUNT_ID` | AWS account ID |
+| `SUBNET_ID_1` | First subnet ID |
+| `SUBNET_ID_2` | Second subnet ID |
+| `SECURITY_GROUP_ID` | Security group ID |
+
+## Environment variables
+
+For a full list of Docker environment variables, please refer to the [Environment variables](/developer/deployment/environment_variables) page.
+
+## ECS tasks
+
+You will need to create two ECS task definitions: one for the web service and one for the worker service.
+
+### Web service
+
+```json
+{
+  "family": "spree-web",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "512",
+  "memory": "1024",
+  "executionRoleArn": "arn:aws:iam::${AWS_ACCOUNT_ID}:role/ecsTaskExecutionRole",
+  "taskRoleArn": "arn:aws:iam::${AWS_ACCOUNT_ID}:role/ecsTaskRole",
+  "containerDefinitions": [
+    {
+      "name": "web",
+      "image": "${ECR_REGISTRY}/${ECR_REPOSITORY}:${IMAGE_TAG}",
+      "portMappings": [
+        {
+          "containerPort": 3000,
+          "protocol": "tcp"
+        }
+      ],
+      "essential": true,
+      "environment": [
+        {
+          "name": "RAILS_ENV",
+          "value": "production"
+        },
+        {
+          "name": "PORT",
+          "value": "3000"
+        }
+      ],
+      "secrets": [
+        {
+          "name": "DATABASE_URL",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/database-url"
+        },
+        {
+          "name": "REDIS_URL",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/redis-url"
+        },
+        {
+          "name": "SECRET_KEY_BASE",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/secret-key-base"
+        }
+      ],
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "options": {
+          "awslogs-group": "/ecs/spree-web",
+          "awslogs-region": "${AWS_REGION}",
+          "awslogs-stream-prefix": "ecs"
+        }
+      },
+      "healthCheck": {
+        "command": ["CMD-SHELL", "curl -f http://localhost:3000/up || exit 1"],
+        "interval": 30,
+        "timeout": 5,
+        "retries": 3,
+        "startPeriod": 60
+      }
+    }
+  ]
+}
+```
+
+### Worker service
+
+```json
+{
+  "family": "spree-worker",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "256",
+  "memory": "512",
+  "executionRoleArn": "arn:aws:iam::${AWS_ACCOUNT_ID}:role/ecsTaskExecutionRole",
+  "taskRoleArn": "arn:aws:iam::${AWS_ACCOUNT_ID}:role/ecsTaskRole",
+  "containerDefinitions": [
+    {
+      "name": "worker",
+      "image": "${ECR_REGISTRY}/${ECR_REPOSITORY}:${IMAGE_TAG}",
+      "command": ["bundle", "exec", "sidekiq"],
+      "essential": true,
+      "environment": [
+        {
+          "name": "RAILS_ENV",
+          "value": "production"
+        }
+      ],
+      "secrets": [
+        {
+          "name": "DATABASE_URL",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/database-url"
+        },
+        {
+          "name": "REDIS_URL",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/redis-url"
+        },
+        {
+          "name": "SECRET_KEY_BASE",
+          "valueFrom": "arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:spree/secret-key-base"
+        }
+      ],
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "options": {
+          "awslogs-group": "/ecs/spree-worker",
+          "awslogs-region": "${AWS_REGION}",
+          "awslogs-stream-prefix": "ecs"
+        }
+      },
+      "healthCheck": {
+        "command": ["CMD-SHELL", "pgrep -f sidekiq || exit 1"],
+        "interval": 30,
+        "timeout": 5,
+        "retries": 3,
+        "startPeriod": 60
+      }
+    }
+  ]
+}
+```

package/dist/developer/deployment/caching.md

@@ -0,0 +1,27 @@
+---
+title: Caching
+description: Configure caching for your Spree application
+---
+
+Caching improves performance by storing the results of expensive database queries and template renders in memory.
+
+## Setting up Redis as Cache Store
+
+Spree comes pre-configured to use Redis for caching in production. Just set the `REDIS_URL` environment variable — no gem installation or code changes needed.
+
+```bash
+REDIS_URL=redis://localhost:6379/0
+```
+
+When `REDIS_URL` is set, Spree automatically uses it for caching. When not set, it falls back to an in-memory cache store.
+
+## Testing Locally
+
+To enable caching in the development environment:
+
+```bash
+cd server
+bin/rails dev:cache
+```
+
+You will need to restart your web server after this.

package/dist/developer/deployment/cdn.md

@@ -0,0 +1,39 @@
+---
+title: CDN
+description: >-
+  Learn how to improve performance of your Spree application by using a CDN (Content Delivery Network).
+---
+
+To improve performance of your Spree application, we recommend using a CDN (Content Delivery Network) to cache images and static files.
+
+We recommend using [Cloudflare](https://www.cloudflare.com/) as your CDN provider. It's free and simple to setup.
+
+After setting up your Cloudflare account and adding your domain name to Cloudflare, you will need to set your cache settings.
+
+Go to your domain name in Cloudflare and click on "Caching" tab and select "Cache Rules".
+
+![Cloudflare Cache Rules](/images/developer/deployment/cloudflare_caching.png)
+
+Click on "Create Rule" and setup the rule as bellow:
+
+![Cloudflare Cache Rule Settings](/images/developer/deployment/cloudflare_cache_rule_1.png)
+
+Supply the first value with
+
+```url
+/rails/active_storage/representations/
+```
+
+and the second value with
+
+```url
+/assets
+```
+
+This will handle caching of both images and static files such as JavaScript and CSS files.
+
+Now scroll down and set the settings as bellow:
+
+![Cloudflare Cache Rule Settings](/images/developer/deployment/cloudflare_cache_rule_2.png)
+
+Finally, click on "Deploy" and you are done!

package/dist/developer/deployment/database.md

@@ -0,0 +1,155 @@
+---
+title: Database Configuration
+description: Learn how to configure Spree to work with PostgreSQL, MySQL, or SQLite.
+---
+
+## Supported Databases
+
+| Database | Development | Production | Notes |
+|----------|:-----------:|:----------:|-------|
+| **PostgreSQL** | Yes | Yes | Recommended for production. Best performance for large catalogs and high traffic |
+| **MySQL** | Yes | Yes | Fully supported. A great choice if your team already uses MySQL |
+| **SQLite** | Yes | Yes | Zero-configuration setup. Ideal for development, small stores, and getting started quickly |
+
+## Configuring Your Database
+
+### Using DATABASE_URL
+
+The simplest way to configure your database is via the `DATABASE_URL` environment variable:
+
+```bash
+# PostgreSQL
+DATABASE_URL=postgres://user:pass@localhost:5432/spree
+
+# MySQL
+DATABASE_URL=mysql2://user:pass@localhost:3306/spree
+
+# SQLite
+DATABASE_URL=sqlite3:db/production.sqlite3
+```
+
+### Using database.yml
+
+You can also configure the database in `config/database.yml`:
+
+**PostgreSQL:**
+
+```yaml
+    default: &default
+      adapter: postgresql
+      encoding: unicode
+      pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+
+    development:
+      <<: *default
+      database: spree_development
+
+    production:
+      <<: *default
+      database: spree_production
+      url: <%= ENV["DATABASE_URL"] %>
+    ```
+
+  **MySQL:**
+
+```yaml
+    default: &default
+      adapter: mysql2
+      encoding: utf8mb4
+      pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+
+    development:
+      <<: *default
+      database: spree_development
+
+    production:
+      <<: *default
+      database: spree_production
+      url: <%= ENV["DATABASE_URL"] %>
+    ```
+
+  **SQLite:**
+
+```yaml
+    default: &default
+      adapter: sqlite3
+      pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+      timeout: 5000
+
+    development:
+      <<: *default
+      database: db/development.sqlite3
+
+    production:
+      <<: *default
+      database: db/production.sqlite3
+    ```
+
+
+## Switching Databases
+
+The easiest way to switch your existing Spree application to a different database is using the built-in Rails command:
+
+```bash
+# Switch to PostgreSQL
+bin/rails db:system:change --to=postgresql
+
+# Switch to MySQL
+bin/rails db:system:change --to=mysql
+
+# Switch to SQLite
+bin/rails db:system:change --to=sqlite3
+```
+
+This command will:
+- Update your `Gemfile` with the correct database gem
+- Generate a new `config/database.yml` configured for the selected database
+
+After running the command, complete the switch:
+
+1. Install the new gem:
+
+    ```bash
+    bundle install
+    ```
+
+2. Create the new database and run migrations:
+
+    ```bash
+    bin/rails db:create db:migrate
+    ```
+
+3. Optionally load sample data:
+
+    ```bash
+    bin/rails spree_sample:load
+    ```
+
+## Creating a New App with a Specific Database
+
+When creating a new Spree application with the manual installation method, pass the `-d` flag to `rails new`:
+
+```bash
+# PostgreSQL
+rails new my_store -d postgresql -m https://raw.githubusercontent.com/spree/spree/main/spree/template.rb
+
+# MySQL
+rails new my_store -d mysql -m https://raw.githubusercontent.com/spree/spree/main/spree/template.rb
+
+# SQLite (default, no flag needed)
+rails new my_store -m https://raw.githubusercontent.com/spree/spree/main/spree/template.rb
+```
+
+## Cloud Database Services
+
+For production deployments, you can use managed database services:
+
+| Provider | PostgreSQL | MySQL |
+|----------|-----------|-------|
+| **AWS** | RDS PostgreSQL, Aurora PostgreSQL | RDS MySQL, Aurora MySQL, RDS MariaDB |
+| **Google Cloud** | Cloud SQL for PostgreSQL | Cloud SQL for MySQL |
+| **Azure** | Azure Database for PostgreSQL | Azure Database for MySQL |
+| **Heroku** | Heroku Postgres | JawsDB, ClearDB |
+| **Render** | Render PostgreSQL | — |
+
+Set the `DATABASE_URL` environment variable to the connection string provided by your cloud provider.

package/dist/developer/deployment/docker.md

@@ -0,0 +1,128 @@
+---
+title: Docker
+description: Run the official Spree Docker image or build your own.
+---
+
+## Official Docker Image
+
+Spree publishes multi-arch Docker images (`linux/amd64` and `linux/arm64`) to the GitHub Container Registry on every release.
+
+```bash
+docker pull ghcr.io/spree/spree:latest
+```
+
+### Available Tags
+
+| Tag | Description |
+|-----|-------------|
+| `latest` | Latest stable release |
+| `5.1.3` | Specific version |
+| `5.1` | Latest patch for a minor version |
+
+Browse all tags on the [GitHub Packages page](https://github.com/spree/spree/pkgs/container/spree).
+
+### Running the Image
+
+The image runs a Puma web server on port 3000. You also need a worker container for background jobs (Sidekiq):
+
+```yaml docker-compose.yml
+services:
+  postgres:
+    image: postgres:17-alpine
+    environment:
+      POSTGRES_HOST_AUTH_METHOD: trust
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: pg_isready -U postgres
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  redis:
+    image: redis:7-alpine
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: redis-cli ping
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  web:
+    image: ghcr.io/spree/spree:latest
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    environment:
+      DATABASE_URL: postgres://postgres@postgres:5432/spree_production
+      REDIS_URL: redis://redis:6379/0
+      SECRET_KEY_BASE: change-me-to-a-real-secret
+      RAILS_FORCE_SSL: "false"
+      RAILS_ASSUME_SSL: "false"
+    ports:
+      - "3000:3000"
+    healthcheck:
+      test: curl -f http://localhost:3000/up || exit 1
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+
+  worker:
+    image: ghcr.io/spree/spree:latest
+    depends_on:
+      web:
+        condition: service_healthy
+    environment:
+      DATABASE_URL: postgres://postgres@postgres:5432/spree_production
+      REDIS_URL: redis://redis:6379/0
+      SECRET_KEY_BASE: change-me-to-a-real-secret
+    command: bundle exec sidekiq
+
+volumes:
+  postgres_data:
+  redis_data:
+```
+
+Start everything:
+
+```bash
+docker compose up -d
+```
+
+The database is automatically created and migrated on first boot. The app is available at [http://localhost:3000](http://localhost:3000).
+
+> **TIP:** Use [create-spree-app](/developer/create-spree-app/quickstart) for a fully scaffolded Docker setup with `.env` files, health checks, and optional Next.js storefront — all configured automatically.
+
+### Required Environment Variables
+
+| Variable | Description | Example |
+| --- | --- | --- |
+| `DATABASE_URL` | PostgreSQL connection URL | `postgres://user:pass@host:5432/spree` |
+| `REDIS_URL` | Redis URL for jobs, caching, and Action Cable | `redis://redis:6379/0` |
+| `SECRET_KEY_BASE` | Secret key for session encryption | Generate with `bin/rails secret` |
+
+See [Environment Variables](/developer/deployment/environment_variables) for the full list.
+
+## Building Your Own Image
+
+If you have your own Rails application with Spree installed, build a Docker image from your app's Dockerfile:
+
+```bash
+docker build -t my-spree .
+```
+
+Then use your custom image in place of `ghcr.io/spree/spree`:
+
+```bash
+docker run -p 3000:3000 \
+  -e DATABASE_URL=postgres://user:pass@host:5432/spree \
+  -e REDIS_URL=redis://localhost:6379/0 \
+  -e SECRET_KEY_BASE=your-secret \
+  my-spree
+```
+
+> **TIP:** When creating a new Rails app with Spree via `rails new -m`, a production-ready Dockerfile is generated automatically by Rails.