# Render API Configuration
variable "render_api_key" {
  description = "Render API key for authentication"
  type        = string
  sensitive   = true
}
variable "render_owner_id" {
  description = "Render account owner ID or team ID"
  type        = string
  sensitive   = true
}
# Service Configuration
variable "service_name" {
  description = "Name of the Render web service"
  type        = string
  default     = "beats-api"
}
variable "service_plan" {
  description = "Render service plan (free, starter, standard, pro, etc.)"
  type        = string
  default     = "free"
}
variable "region" {
  description = "Render region to deploy to"
  type        = string
  default     = "oregon"
}
# GitHub Repository Configuration
variable "github_repo_url" {
  description = "GitHub repository URL (format: https://github.com/owner/repo)"
  type        = string
  default     = "https://github.com/lanterno/beats"
}
variable "github_branch" {
  description = "Git branch to deploy from"
  type        = string
  default     = "main"
}
# Database Configuration
variable "db_dsn" {
  description = "MongoDB connection string (e.g., mongodb+srv://user:pass@cluster.mongodb.net)"
  type        = string
  sensitive   = true
}
variable "db_name" {
  description = "MongoDB database name"
  type        = string
  default     = "beats"
}
# Application Configuration
variable "access_token" {
  description = "API access token for authentication"
  type        = string
  sensitive   = true
}
variable "auto_deploy" {
  description = "Enable auto-deploy on git push"
  type        = bool
  default     = true
}
# Custom Domain Configuration (optional)
variable "custom_domain" {
  description = "Custom domain to attach to the web service (e.g., beats.elghareeb.space). Leave empty to disable."
  type        = string
  default     = ""
}

# Example Terraform variables file
# Copy this to terraform.tfvars and fill in your actual values
# WARNING: Never commit terraform.tfvars with real credentials!
# Render API key - get from https://dashboard.render.com/account/api-keys
render_api_key = "rnd_YOUR_RENDER_API_KEY_HERE"
# Render Owner ID - find at https://dashboard.render.com/settings
# This is your account ID (starts with usr-) or team ID (starts with tea-)
render_owner_id = "usr-YOUR_OWNER_ID_HERE"
# Service configuration
service_name = "beats-api"
service_plan = "free"  # Options: free, starter, standard, pro
region       = "oregon"  # Options: oregon, frankfurt, singapore, ohio, virginia
# GitHub repository (already set to your repo)
github_repo_url = "https://github.com/lanterno/beats"
github_branch   = "main"
# MongoDB connection string from MongoDB Atlas or other provider
db_dsn = "mongodb+srv://username:password@cluster.mongodb.net/?retryWrites=true&w=majority"
# Database name
db_name = "beats"
# API access token for authentication
access_token = "your-secure-random-token-here"
# Auto-deploy on git push
auto_deploy = true

output "service_id" {
  description = "Render service ID"
  value       = render_web_service.beats_api.id
}
output "service_url" {
  description = "Public URL of the deployed service"
  value       = render_web_service.beats_api.url
}
output "service_name" {
  description = "Name of the deployed service"
  value       = render_web_service.beats_api.name
}
output "deploy_url" {
  description = "Dashboard URL to view the service"
  value       = "https://dashboard.render.com/web/${render_web_service.beats_api.id}"
}
output "service_host_for_dns" {
  description = "Host to use as CNAME target for your custom domain (copy the host from this URL)"
  value       = render_web_service.beats_api.url
}

terraform {
  required_version = ">= 1.10"
  
  required_providers {
    render = {
      source  = "render-oss/render"
      version = "~> 1.7.5"
    }
  }
}
provider "render" {
  api_key  = var.render_api_key
  owner_id = var.render_owner_id
}
# Web service for the Beats FastAPI application
resource "render_web_service" "beats_api" {
  name   = var.service_name
  plan   = var.service_plan
  region = var.region
  
  runtime_source = {
    docker = {
      dockerfile_path = "ops/Dockerfile"
      docker_context  = "."
      repo_url        = var.github_repo_url
      branch          = var.github_branch
      auto_deploy     = var.auto_deploy
    }
  }
  
  # Environment variables
  env_vars = {
    PORT = {
      value = "10000"
    }
    DB_DSN = {
      value = var.db_dsn
    }
    DB_NAME = {
      value = var.db_name
    }
    ACCESS_TOKEN = {
      value = var.access_token
    }
  }
  
  # Health check configuration
  health_check_path = "/talk/ding"
}
# Note: The Render Terraform provider (v1.7.x) does not support managing custom domains.
# To use a custom domain (e.g., beats.elghareeb.space), add it in the Render dashboard
# under the Web Service -> Custom Domains, and create the suggested DNS record at your
# DNS provider. SSL will be provisioned automatically by Render.

# Terraform Deployment to Render.com
This directory contains Terraform configuration to deploy the Beats FastAPI application to Render.com.
## Prerequisites
1. **Render Account**: Sign up at [render.com](https://render.com)
2. **Render API Key**: Generate from [dashboard.render.com/account/api-keys](https://dashboard.render.com/account/api-keys)
3. **Render Owner ID**: Find in [dashboard.render.com/settings](https://dashboard.render.com/settings) under "Account ID" (starts with `usr-`) or "Team ID" (starts with `tea-`)
4. **MongoDB Atlas** (or other MongoDB provider): Get connection string
5. **Terraform**: Install from [terraform.io/downloads](https://terraform.io/downloads)
6. **GitHub Repository**: Your code should be pushed to GitHub
## Quick Start
### 1. Configure Variables
Copy the example variables file and fill in your values:
```bash
cd terraform
cp terraform.tfvars.example terraform.tfvars
```
Edit `terraform.tfvars` with your actual values:
- `render_api_key`: Your Render API key from [dashboard.render.com/account/api-keys](https://dashboard.render.com/account/api-keys)
- `render_owner_id`: Your account ID from [dashboard.render.com/settings](https://dashboard.render.com/settings) (starts with `usr-` or `tea-`)
- `db_dsn`: MongoDB connection string (e.g., from MongoDB Atlas)
- `access_token`: Generate a secure random token for API authentication
**⚠️ IMPORTANT**: Never commit `terraform.tfvars` to version control!
### 2. Initialize Terraform
```bash
terraform init
```
This downloads the Render provider plugin.
### 3. Review the Plan
```bash
terraform plan
```
Review the resources that will be created.
### 4. Deploy
```bash
terraform apply
```
Type `yes` when prompted to confirm deployment.
### 5. Get Service URL
After deployment completes, Terraform will output your service URL:
```bash
terraform output service_url
```
## Configuration
### Service Plans
Available Render plans (set in `service_plan` variable):
- `free`: 750 hours/month, sleeps after 15 min inactivity
- `starter`: $7/month, always on
- `standard`: $25/month, higher resources
- `pro`: Custom pricing
### Regions
Available regions (set in `region` variable):
- `oregon` (US West)
- `frankfurt` (EU)
- `singapore` (Asia)
- `ohio` (US East)
- `virginia` (US East)
### Environment Variables
The following environment variables are automatically configured:
- `PORT`: Set to 10000 (Render default)
- `DB_DSN`: MongoDB connection string
- `DB_NAME`: Database name
- `ACCESS_TOKEN`: API authentication token
## MongoDB Setup
### Using MongoDB Atlas (Recommended)
1. Create account at [mongodb.com/cloud/atlas](https://www.mongodb.com/cloud/atlas)
2. Create a free cluster
3. Create a database user
4. Add `0.0.0.0/0` to IP whitelist (for Render access)
5. Get connection string (format: `mongodb+srv://...`)
6. Use this as `db_dsn` in `terraform.tfvars`
## Managing the Deployment
### View Service Status
```bash
terraform show
```
### Update Configuration
1. Edit variables in `terraform.tfvars`
2. Run `terraform plan` to review changes
3. Run `terraform apply` to apply changes
### Destroy Service
```bash
terraform destroy
```
## Troubleshooting
### Check Service Logs
Visit: https://dashboard.render.com/web/{service_id}
Or use Terraform output:
```bash
terraform output deploy_url
```
### Health Check
Your service health check endpoint is `/talk/ding`
Test after deployment:
```bash
curl https://your-service.onrender.com/talk/ding
```
Should return: `{"message": "dong"}`
### Service Not Starting
1. Check logs in Render dashboard
2. Verify Docker build succeeds locally: `make test`
3. Verify environment variables are set correctly
4. Ensure MongoDB connection string is correct and accessible
## CI/CD
By default, `auto_deploy = true` means Render will automatically deploy when you push to the configured branch (`main`).
To disable auto-deploy:
```hcl
auto_deploy = false
```
## Cost Estimation
- **Free Plan**: $0/month (sleeps after 15 min inactivity)
- **MongoDB Atlas Free**: $0/month (512 MB storage)
**Total minimum cost**: $0/month
For production, consider:
- **Starter Plan**: $7/month (always on)
- **MongoDB Atlas M10**: ~$57/month (dedicated cluster)
## Security Notes
1. Never commit `terraform.tfvars` or any file with credentials
2. Use strong, random tokens for `access_token`
3. Rotate API keys and tokens regularly
4. Restrict MongoDB IP whitelist in production
5. Consider using Terraform Cloud for state management
## Support
- Render Documentation: [render.com/docs](https://render.com/docs)
- Terraform Render Provider: [registry.terraform.io/providers/render-oss/render](https://registry.terraform.io/providers/render-oss/render/latest/docs)
- Beats API Issues: [github.com/lanterno/beats/issues](https://github.com/lanterno/beats/issues)

# Terraform state files
.terraform/
*.tfstate
*.tfstate.*
*.tfstate.backup
# Terraform variables with sensitive data
terraform.tfvars
*.auto.tfvars
# Crash log files
crash.log
crash.*.log
# CLI configuration files
.terraformrc
terraform.rc
# Provider cache
.terraform.lock.hcl
# Override files
override.tf
override.tf.json
*_override.tf
*_override.tf.json
# Plan files
*.tfplan

src/.env

src/.env
# Terraform
terraform/.terraform/
terraform/*.tfstate
terraform/*.tfstate.*
terraform/terraform.tfvars
terraform/*.auto.tfvars
terraform/.terraform.lock.hcl