
At Pangea, we use Terraform to manage our GCP infrastructure for the FX and payments platform. Infrastructure as code enables version control, reproducibility, and safer deployments.

#### Why Terraform?

Terraform provides:
- Declarative infrastructure
- Version control
- State management
- Multi-cloud support
- Plan before apply

#### Our Setup

```hcl
# main.tf
terraform {
  required_version = ">= 1.0"
  
  backend "gcs" {
    bucket = "pangea-terraform-state"
    prefix = "production"
  }
  
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}
```

#### Cloud Run Services

```hcl
resource "google_cloud_run_service" "api" {
  name     = "pangea-api"
  location = var.region
  
  template {
    spec {
      containers {
        image = "gcr.io/${var.project_id}/api:${var.image_tag}"
        
        resources {
          limits = {
            cpu    = "2"
            memory = "4Gi"
          }
        }
        
        env {
          name  = "DATABASE_URL"
          value = var.database_url
        }
      }
    }
    
    metadata {
      annotations = {
        "autoscaling.knative.dev/maxScale" = "100"
        "run.googleapis.com/cloudsql-instances" = google_sql_database_instance.main.connection_name
      }
    }
  }
  
  traffic {
    percent         = 100
    latest_revision = true
  }
}
```

#### Pub/Sub Topics

```hcl
resource "google_pubsub_topic" "payment_events" {
  name = "payment-events"
  
  message_retention_duration = "604800s" # 7 days
}

resource "google_pubsub_subscription" "payment_processor" {
  name  = "payment-processor-sub"
  topic = google_pubsub_topic.payment_events.name
  
  ack_deadline_seconds = 60
  
  expiration_policy {
    ttl = "300000.5s" # ~3.5 days
  }
  
  retry_policy {
    minimum_backoff = "10s"
    maximum_backoff = "600s"
  }
}
```

#### Best Practices

- Use modules for reusable components
- Separate environments (dev, staging, prod)
- Lock state files
- Review plans before applying
- Use variables for configuration
- Document everything

> "Infrastructure as code is essential for reliability."

#### Lessons Learned

1. Start with modules early
2. Use remote state
3. Review plans carefully
4. Test in dev first
5. Keep state files secure



Managing GCP infrastructure with Terraform at Pangea


Leading the migration from Heroku to AWS at Heard was one of the most challenging infrastructure projects I've managed. We cut costs by 20% and improved uptime from 97.5% to 99.9%, but the journey was complex.

#### Why Migrate?

Heroku was great for getting started, but as we scaled:
- Costs grew faster than revenue
- Limited control over infrastructure
- Performance bottlenecks
- Compliance requirements needed more control

#### The Migration Strategy

We used a phased approach:
1. **Assessment**: Inventory all services and dependencies
2. **Parallel Run**: Run both environments simultaneously
3. **Gradual Cutover**: Move services one by one
4. **Optimization**: Tune AWS services for cost and performance

#### Key Decisions

**ECS vs EC2**: Chose ECS for container orchestration
**RDS vs Self-Managed**: RDS for managed Postgres
**CloudFront**: For CDN and caching
**Terraform**: Infrastructure as code

#### Challenges

- Database migration was the hardest part
- DNS cutover timing
- Team training on AWS services
- Monitoring and alerting setup

#### Results

- 20% cost reduction
- 99.9% uptime (up from 97.5%)
- Better performance and scalability
- More control over infrastructure

#### Lessons

1. Plan for 2x the time you think you need
2. Test migrations thoroughly in staging
3. Have rollback plans for every step
4. Communicate progress regularly
5. Invest in monitoring from day one

> "A successful migration is one where users don't notice it happened."



infrastructure

Managing GCP infrastructure with Terraform at Pangea

Migrating from Heroku to AWS: lessons learned