Terraform Infrastructure as Code Guide for RamNode VPS

Understanding RamNode's Infrastructure Model

RamNode operates differently from traditional cloud providers like AWS or Azure. Instead of offering APIs for programmatic resource creation, RamNode provides pre-configured VPS instances that you can order through their control panel.

RamNode Key Features

• High-performance SSD and NVMe storage
• Multiple data center locations
• Competitive pricing with excellent ratios
• KVM virtualization for better isolation
• DDoS protection supported
• IPv6 support across all locations

IaC Approach

• Hybrid manual + automated setup
• Terraform for configuration management
• Ansible for detailed provisioning
• Version-controlled infrastructure

Terraform Strategy for RamNode

Since RamNode doesn't provide a native Terraform provider, we'll use a hybrid approach combining manual VPS provisioning with automated configuration management.

Approach 1: External Provider with Local-Exec

Main Terraform Configuration

# main.tf
terraform {
  required_providers {
    null = {
      source  = "hashicorp/null"
      version = "~> 3.0"
    }
  }
}

# Variables for RamNode VPS configuration
variable "ramnode_servers" {
  description = "RamNode server configurations"
  type = map(object({
    ip_address = string
    hostname   = string
    location   = string
    plan       = string
  }))

  default = {
    web_server = {
      ip_address = "192.168.1.100"
      hostname   = "web.example.com"
      location   = "ATL"
      plan       = "1GB Standard"
    }
    db_server = {
      ip_address = "192.168.1.101"
      hostname   = "db.example.com"
      location   = "ATL"
      plan       = "2GB Standard"
    }
  }
}

# Null resource to trigger server setup
resource "null_resource" "ramnode_setup" {
  for_each = var.ramnode_servers

  triggers = {
    server_config = jsonencode(each.value)
  }

  provisioner "local-exec" {
    command = "./scripts/setup_ramnode_server.sh ${each.value.ip_address} ${each.value.hostname}"
  }

  provisioner "remote-exec" {
    inline = [
      "sudo apt-get update",
      "sudo apt-get install -y docker.io",
      "sudo systemctl enable docker",
      "sudo systemctl start docker"
    ]

    connection {
      type        = "ssh"
      user        = "root"
      host        = each.value.ip_address
      private_key = file("~/.ssh/ramnode_key")
    }
  }
}

Approach 2: Using the Generic HTTP Provider

HTTP Provider Configuration

# providers.tf
terraform {
  required_providers {
    http = {
      source  = "hashicorp/http"
      version = "~> 3.0"
    }
  }
}

# Data source to check server status
data "http" "server_status" {
  url = "https://your-ramnode-panel.com/api/server/status"

  request_headers = {
    Authorization = "Bearer ${var.api_token}"
  }
}

# Local values for server management
locals {
  server_status = jsondecode(data.http.server_status.response_body)
}

Directory Structure Setup

Organize your Terraform project with a clear directory structure that follows best practices for Infrastructure as Code:

Project Directory Structure

ramnode-terraform/
├── main.tf                    # Main Terraform configuration
├── variables.tf               # Variable definitions
├── outputs.tf                 # Output values
├── terraform.tfvars          # Variable values (keep secure)
├── providers.tf              # Provider configurations
├── versions.tf               # Version constraints
├── README.md                 # Project documentation
├── .gitignore               # Git ignore file
├── scripts/                 # Setup and utility scripts
│   ├── setup_ramnode_server.sh
│   ├── configure_firewall.sh
│   └── backup_config.sh
├── ansible/                 # Ansible playbooks
│   ├── playbook.yml
│   ├── inventory.ini
│   └── roles/
│       ├── common/
│       ├── webserver/
│       └── database/
├── configs/                 # Configuration templates
│   ├── nginx.conf
│   ├── docker-compose.yml
│   └── monitoring.yml
└── modules/                 # Reusable Terraform modules
    ├── web_server/
    │   ├── main.tf
    │   ├── variables.tf
    │   └── outputs.tf
    └── database/
        ├── main.tf
        ├── variables.tf
        └── outputs.tf

📋 Key Directory Purposes

scripts/: Shell scripts for server setup and maintenance
ansible/: Configuration management playbooks
configs/: Template files for services
modules/: Reusable Terraform components

Variables Configuration

Define variables for flexible infrastructure management:

variables.tf

# variables.tf
variable "ssh_public_key" {
  description = "SSH public key for server access"
  type        = string
}

variable "domain_name" {
  description = "Primary domain name"
  type        = string
  default     = "example.com"
}

variable "environment" {
  description = "Environment name"
  type        = string
  default     = "production"
}

variable "ramnode_location" {
  description = "RamNode data center location"
  type        = string
  default     = "ATL"

  validation {
    condition = contains([
      "ATL", "LAX", "EWR",
      "NLX", "SEA"
    ], var.ramnode_location)
    error_message = "Location must be a valid RamNode data center."
  }
}

Server Configuration Module

Create reusable modules for different server types:

modules/web_server/main.tf

# modules/web_server/main.tf
resource "null_resource" "web_server_config" {
  count = var.server_count

  provisioner "remote-exec" {
    inline = [
      "sudo apt-get update",
      "sudo apt-get install -y nginx certbot python3-certbot-nginx",
      "sudo systemctl enable nginx",
      "sudo systemctl start nginx",
      "sudo ufw allow 'Nginx Full'",
      "sudo ufw allow ssh",
      "sudo ufw --force enable"
    ]

    connection {
      type        = "ssh"
      user        = "root"
      host        = var.server_ips[count.index]
      private_key = file(var.ssh_private_key_path)
    }
  }

  provisioner "file" {
    source      = "configs/nginx.conf"
    destination = "/etc/nginx/sites-available/default"

    connection {
      type        = "ssh"
      user        = "root"
      host        = var.server_ips[count.index]
      private_key = file(var.ssh_private_key_path)
    }
  }

  provisioner "remote-exec" {
    inline = [
      "sudo nginx -t",
      "sudo systemctl reload nginx",
      "sudo certbot --nginx -d ${var.domain_name} --non-interactive --agree-tos -m admin@${var.domain_name}"
    ]

    connection {
      type        = "ssh"
      user        = "root"
      host        = var.server_ips[count.index]
      private_key = file(var.ssh_private_key_path)
    }
  }
}

Ansible Integration

For complex configuration management, combine Terraform with Ansible:

Ansible Integration

# ansible_integration.tf
resource "null_resource" "ansible_playbook" {
  depends_on = [null_resource.ramnode_setup]

  provisioner "local-exec" {
    command = "ansible-playbook -i ansible/inventory.ini ansible/playbook.yml"
  }

  triggers = {
    playbook_hash = filemd5("ansible/playbook.yml")
  }
}

Sample Ansible Playbook

# ansible/playbook.yml
---
- hosts: ramnode_servers
  become: yes
  vars:
    nodejs_version: "18"

  tasks:
    - name: Update package cache
      apt:
        update_cache: yes

    - name: Install required packages
      apt:
        name:
          - curl
          - git
          - htop
          - vim
          - fail2ban
        state: present

    - name: Configure fail2ban
      copy:
        dest: /etc/fail2ban/jail.local
        content: |
          [DEFAULT]
          bantime = 3600
          findtime = 600
          maxretry = 3

          [sshd]
          enabled = true

    - name: Start and enable fail2ban
      systemd:
        name: fail2ban
        state: started
        enabled: yes

Monitoring and Outputs

Configure monitoring and useful outputs for your infrastructure:

outputs.tf

# outputs.tf
output "server_information" {
  description = "RamNode server details"
  value = {
    for k, v in var.ramnode_servers : k => {
      ip_address = v.ip_address
      hostname   = v.hostname
      location   = v.location
      ssh_command = "ssh root@${v.ip_address}"
    }
  }
}

output "deployment_timestamp" {
  description = "When the infrastructure was deployed"
  value = timestamp()
}

Security Hardening

Implement security best practices for your RamNode infrastructure:

Security Essentials

• SSH Key Management
• Firewall Configuration
• Regular Updates
• Fail2ban Protection

Best Practices

• Use SSH keys instead of passwords
• Implement UFW or iptables rules
• Automate security updates
• Monitor system logs

Backup Strategy

Implement automated backup strategies:

Backup Setup

resource "null_resource" "backup_setup" {
  for_each = var.ramnode_servers

  provisioner "remote-exec" {
    inline = [
      "sudo apt-get install -y rsync",
      "mkdir -p /opt/backups",
      "echo '0 2 * * * /opt/scripts/backup.sh' | sudo crontab -"
    ]

    connection {
      type        = "ssh"
      user        = "root"
      host        = each.value.ip_address
      private_key = file("~/.ssh/ramnode_key")
    }
  }
}

💡 Cost Optimization Tips: Right-size VPS plans, select optimal data centers, monitor resources, and plan for traffic patterns.

Deployment Workflow

Follow this workflow for reliable deployments:

Manual VPS Ordering: Order your RamNode VPS instances through their control panel

SSH Key Setup: Configure SSH keys for secure access

Terraform Planning: Run terraform plan to review changes

Infrastructure Deployment: Execute terraform apply

Configuration Management: Let Ansible handle detailed configuration

Testing and Validation: Verify all services are running correctly

Troubleshooting Common Issues

Common issues and their solutions:

Connection Problems

Test SSH Connectivity

# Test SSH connectivity
ssh -o ConnectTimeout=10 root@your-ramnode-ip

# Check if the server is responding
ping your-ramnode-ip

Terraform State Management

State Management Commands

# Import existing resources
terraform import null_resource.ramnode_setup.web_server web_server

# Refresh state
terraform refresh

⚠️ Important: Always test your configurations in a development environment before applying them to production servers, and maintain regular backups of both your infrastructure code and server data.

Conclusion

While RamNode doesn't provide native Terraform support, you can still achieve Infrastructure as Code benefits through creative use of Terraform's provisioners, null resources, and integration with configuration management tools like Ansible.

This hybrid approach provides the benefits of IaC while taking advantage of RamNode's excellent price-to-performance ratio and reliable hosting platform. The key is to treat your RamNode VPS instances as the foundation layer, then use Terraform and Ansible to build your application infrastructure on top.

Deploying Infrastructure with Terraform

📋 Guide Contents

Understanding RamNode's Infrastructure Model

RamNode Key Features

IaC Approach

Terraform Strategy for RamNode

Approach 1: External Provider with Local-Exec

Approach 2: Using the Generic HTTP Provider

Directory Structure Setup

📋 Key Directory Purposes

Variables Configuration

Server Configuration Module

Ansible Integration

Monitoring and Outputs

Security Hardening

Security Essentials

Best Practices

Backup Strategy

Deployment Workflow

Troubleshooting Common Issues

Connection Problems

Terraform State Management

Conclusion