diff --git a/ansible/defaults/rqlite.yml b/ansible/defaults/rqlite.yml new file mode 100644 index 0000000..d83658f --- /dev/null +++ b/ansible/defaults/rqlite.yml @@ -0,0 +1,18 @@ +--- +# rqlite configuration +rqlite_version: "8.36.11" +rqlite_http_port: 4001 +rqlite_raft_port: 4002 +rqlite_data_dir: "/home/{{ ansible_user }}/data" +rqlite_extract_dir: "/opt/rqlite" +rqlite_download_url: "https://github.com/rqlite/rqlite/releases/download/v{{ rqlite_version }}/rqlite-v{{ rqlite_version }}-linux-amd64.tar.gz" + +# Node resources +node_cpus: 2 +node_memory: 2G +node_disk: 10G + +# DNS configuration +dns_servers: + - "8.8.8.8" + - "8.8.4.4" diff --git a/ansible/playbooks/rqlite.yml b/ansible/playbooks/rqlite.yml new file mode 100644 index 0000000..265d7fe --- /dev/null +++ b/ansible/playbooks/rqlite.yml @@ -0,0 +1,53 @@ +--- +# ansible/playbooks/rqlite.yml +- name: Common configuration for all rqlite nodes + hosts: rqlite_cluster + become: yes + vars_files: + - ../defaults/rqlite.yml + tags: + - common + tasks: + - include_tasks: ../tasks/kubernetes/setup-hosts.yml + - include_tasks: ../tasks/kubernetes/update-dns.yml + - include_tasks: ../tasks/kubernetes/ssh.yml + +- name: Setup all rqlite nodes + hosts: rqlite_cluster + become: yes + vars_files: + - ../defaults/rqlite.yml + tags: + - rqlite-setup + tasks: + - include_tasks: ../tasks/rqlite/node-setup.yml + +- name: Initialize rqlite leader node + hosts: rqlite_leader + become: yes + vars_files: + - ../defaults/rqlite.yml + tags: + - leader + tasks: + - include_tasks: ../tasks/rqlite/leader-init.yml + +- name: Join follower nodes to cluster + hosts: rqlite_followers + become: yes + vars_files: + - ../defaults/rqlite.yml + tags: + - followers + tasks: + - include_tasks: ../tasks/rqlite/follower-join.yml + +- name: Validate rqlite cluster + hosts: rqlite_cluster + become: yes + vars_files: + - ../defaults/rqlite.yml + tags: + - validate + tasks: + - include_tasks: ../tasks/rqlite/validate-cluster.yml diff --git a/ansible/tasks/rqlite/follower-join.yml b/ansible/tasks/rqlite/follower-join.yml new file mode 100644 index 0000000..ac4ea65 --- /dev/null +++ b/ansible/tasks/rqlite/follower-join.yml @@ -0,0 +1,39 @@ +--- +# ansible/tasks/rqlite/follower-join.yml +- name: Create follower service file + copy: + dest: /etc/systemd/system/rqlited.service + content: | + [Unit] + Description=rqlite distributed SQLite follower node + After=network.target + + [Service] + Type=simple + User={{ ansible_user }} + Group={{ ansible_user }} + WorkingDirectory=/home/{{ ansible_user }} + ExecStart=/usr/local/bin/rqlited -node-id {{ groups['rqlite_nodes'].index(inventory_hostname) + 1 }} -http-addr {{ ansible_host }}:{{ rqlite_http_port }} -raft-addr {{ ansible_host }}:{{ rqlite_raft_port }} -join {{ hostvars[groups['rqlite_leader'][0]]['ansible_host'] }}:{{ rqlite_raft_port }} {{ rqlite_data_dir }} + Restart=on-failure + RestartSec=5 + + [Install] + WantedBy=multi-user.target + +- name: Configure firewall (UFW) + ufw: + rule: allow + port: "{{ item }}" + proto: tcp + with_items: + - "{{ rqlite_http_port }}" + - "{{ rqlite_raft_port }}" + when: ansible_os_family == "Debian" + ignore_errors: yes # In case UFW isn't installed + +- name: Start and enable rqlite service on follower node + systemd: + name: rqlited + enabled: yes + daemon_reload: yes + state: started diff --git a/ansible/tasks/rqlite/leader-init.yml b/ansible/tasks/rqlite/leader-init.yml new file mode 100644 index 0000000..79ed080 --- /dev/null +++ b/ansible/tasks/rqlite/leader-init.yml @@ -0,0 +1,61 @@ +--- +# ansible/tasks/rqlite/leader-init.yml +- name: Create leader service file + copy: + dest: /etc/systemd/system/rqlited.service + content: | + [Unit] + Description=rqlite distributed SQLite leader node + After=network.target + + [Service] + Type=simple + User={{ ansible_user }} + Group={{ ansible_user }} + WorkingDirectory=/home/{{ ansible_user }} + ExecStart=/usr/local/bin/rqlited -node-id 1 -http-addr {{ ansible_host }}:{{ rqlite_http_port }} -raft-addr {{ ansible_host }}:{{ rqlite_raft_port }} {{ rqlite_data_dir }} + Restart=on-failure + RestartSec=5 + + [Install] + WantedBy=multi-user.target + +- name: Configure firewall (UFW) + ufw: + rule: allow + port: "{{ item }}" + proto: tcp + with_items: + - "{{ rqlite_http_port }}" + - "{{ rqlite_raft_port }}" + when: ansible_os_family == "Debian" + ignore_errors: yes # In case UFW isn't installed + +- name: Start and enable rqlite service on leader node + systemd: + name: rqlited + enabled: yes + daemon_reload: yes + state: started + +- name: Wait for leader node to be fully operational + uri: + url: "http://{{ ansible_host }}:{{ rqlite_http_port }}/readyz" + return_content: yes + register: leader_ready + until: leader_ready.status == 200 + retries: 12 # Try for up to 1 minute (5 seconds × 12) + delay: 5 # 5 second delay between retries + +- name: Ensure leader has stabilized + pause: + seconds: 5 + +- name: Check leader status + shell: "curl -s http://{{ ansible_host }}:{{ rqlite_http_port }}/status?pretty" + register: leader_status + changed_when: false + +- name: Display leader status + debug: + var: leader_status.stdout_lines diff --git a/ansible/tasks/rqlite/node-setup.yml b/ansible/tasks/rqlite/node-setup.yml new file mode 100644 index 0000000..77e026b --- /dev/null +++ b/ansible/tasks/rqlite/node-setup.yml @@ -0,0 +1,52 @@ +--- +# ansible/tasks/rqlite/node-setup.yml +- name: Install required packages + apt: + name: + - tar + - wget + - curl + state: present + update_cache: yes + when: ansible_os_family == "Debian" + +- name: Install required packages (RHEL/CentOS) + yum: + name: + - tar + - wget + - curl + state: present + when: ansible_os_family == "RedHat" + +- name: Create rqlite directories + file: + path: "{{ item }}" + state: directory + mode: '0755' + owner: "{{ ansible_user }}" + group: "{{ ansible_user }}" + with_items: + - "{{ rqlite_extract_dir }}" + - "{{ rqlite_data_dir }}" + +- name: Download and extract rqlite + unarchive: + src: "{{ rqlite_download_url }}" + dest: "{{ rqlite_extract_dir }}" + remote_src: yes + creates: "{{ rqlite_extract_dir }}/rqlited" + extra_opts: + - --strip-components=1 + owner: "{{ ansible_user }}" + group: "{{ ansible_user }}" + +- name: Copy rqlite binaries to /usr/local/bin + copy: + src: "{{ rqlite_extract_dir }}/{{ item }}" + dest: "/usr/local/bin/{{ item }}" + mode: '0755' + remote_src: yes + with_items: + - rqlited + - rqlite diff --git a/ansible/tasks/rqlite/validate-cluster.yml b/ansible/tasks/rqlite/validate-cluster.yml new file mode 100644 index 0000000..b7a5e92 --- /dev/null +++ b/ansible/tasks/rqlite/validate-cluster.yml @@ -0,0 +1,43 @@ +--- +# ansible/tasks/rqlite/validate-cluster.yml +- name: Wait for all nodes to be up + uri: + url: "http://{{ hostvars[item]['ansible_host'] }}:{{ rqlite_http_port }}/readyz" + return_content: yes + register: node_ready + until: node_ready.status == 200 + retries: 12 + delay: 5 + with_items: "{{ groups['rqlite_nodes'] }}" + delegate_to: localhost + run_once: true + +- name: Check cluster status + shell: "curl -s http://{{ hostvars[groups['rqlite_leader'][0]]['ansible_host'] }}:{{ rqlite_http_port }}/nodes?pretty" + register: cluster_status + changed_when: false + delegate_to: localhost + run_once: true + +- name: Display cluster status + debug: + var: cluster_status.stdout_lines + delegate_to: localhost + run_once: true + +- name: Verify node count + debug: + msg: "Successfully configured {{ groups['rqlite_nodes'] | length }} rqlite nodes" + delegate_to: localhost + run_once: true + +- name: Display cluster information + debug: + msg: + - "rqlite cluster validation summary:" + - "Leader node: {{ hostvars[groups['rqlite_leader'][0]]['ansible_host'] }}" + - "Follower nodes: {{ groups['rqlite_followers'] | map('extract', hostvars, ['ansible_host']) | join(', ') }}" + - "HTTP API port: {{ rqlite_http_port }}" + - "Raft consensus port: {{ rqlite_raft_port }}" + delegate_to: localhost + run_once: true diff --git a/cli/cmd/provision/cmd/provision.go b/cli/cmd/provision/cmd/provision.go index 2538a72..7f84897 100644 --- a/cli/cmd/provision/cmd/provision.go +++ b/cli/cmd/provision/cmd/provision.go @@ -5,20 +5,21 @@ import ( "github.com/bxtal-lsn/kubernetes/cli/cmd/provision/interactive" "github.com/bxtal-lsn/kubernetes/cli/cmd/provision/kubernetes" + "github.com/bxtal-lsn/kubernetes/cli/cmd/provision/rqlite" "github.com/spf13/cobra" ) var provisionCmd = &cobra.Command{ Use: "provision", Short: "Provision infrastructure components", - Long: `Provision infrastructure components like Kubernetes clusters, PostgreSQL, etc.`, + Long: `Provision infrastructure components like Kubernetes clusters, RQLite, etc.`, Run: func(cmd *cobra.Command, args []string) { provisionInteractive() }, } func provisionInteractive() { - options := []string{"Kubernetes Cluster", "PostgreSQL Cluster"} + options := []string{"Kubernetes Cluster", "RQLite Cluster"} choice, err := interactive.PromptSelect("What would you like to provision?", options) if err != nil { exitWithError("Failed to get user input", err) @@ -30,6 +31,12 @@ func provisionInteractive() { if err := kubernetes.ProvisionInteractive(); err != nil { exitWithError("Failed to provision Kubernetes cluster", err) } + case "RQLite Cluster": + fmt.Println("Starting RQLite cluster provisioning...") + if err := rqlite.ProvisionInteractive(); err != nil { + exitWithError("Failed to provision RQLite cluster", err) + } + default: fmt.Println("Invalid choice") } diff --git a/cli/cmd/provision/rqlite/provision.go b/cli/cmd/provision/rqlite/provision.go new file mode 100644 index 0000000..183b409 --- /dev/null +++ b/cli/cmd/provision/rqlite/provision.go @@ -0,0 +1,219 @@ +package rqlite + +import ( + "fmt" + "os" + "os/exec" + "path/filepath" + + "github.com/bxtal-lsn/kubernetes/cli/cmd/provision/config" + "github.com/bxtal-lsn/kubernetes/cli/cmd/provision/interactive" + "gopkg.in/yaml.v3" +) + +// Config holds rqlite cluster configuration +type Config struct { + RqliteVersion string `yaml:"rqlite_version"` + RqliteHttpPort int `yaml:"rqlite_http_port"` + RqliteRaftPort int `yaml:"rqlite_raft_port"` + RqliteDataDir string `yaml:"rqlite_data_dir"` + RqliteExtractDir string `yaml:"rqlite_extract_dir"` + NodeCPUs int `yaml:"node_cpus"` + NodeMemory string `yaml:"node_memory"` + NodeDisk string `yaml:"node_disk"` + DNSServers []string `yaml:"dns_servers"` +} + +// LoadDefaultConfig loads the default rqlite configuration from the defaults file +func LoadDefaultConfig() (*Config, error) { + defaultsPath, err := config.GetAnsiblePath("defaults/rqlite.yml") + if err != nil { + return nil, fmt.Errorf("failed to locate defaults file: %w\n"+ + "Please make sure you are running the command from within the repository and that the ansible/defaults/rqlite.yml file exists", err) + } + + data, err := os.ReadFile(defaultsPath) + if err != nil { + return nil, fmt.Errorf("failed to read defaults file at %s: %w\n"+ + "Please check file permissions and that the repository is correctly cloned", defaultsPath, err) + } + + config := &Config{} + err = yaml.Unmarshal(data, config) + if err != nil { + return nil, fmt.Errorf("failed to parse defaults file: %w", err) + } + + return config, nil +} + +// SaveConfig saves the rqlite configuration to a temporary file +func SaveConfig(config *Config) (string, error) { + data, err := yaml.Marshal(config) + if err != nil { + return "", fmt.Errorf("failed to marshal config: %w", err) + } + + // Create a temporary directory + tmpDir, err := os.MkdirTemp("", "rqlite-provision") + if err != nil { + return "", fmt.Errorf("failed to create temp dir: %w", err) + } + + // Write config to a file + configPath := filepath.Join(tmpDir, "rqlite.yml") + err = os.WriteFile(configPath, data, 0o644) + if err != nil { + return "", fmt.Errorf("failed to write config file: %w", err) + } + + return configPath, nil +} + +// ProvisionInteractive handles interactive rqlite cluster provisioning +func ProvisionInteractive() error { + // Load default configuration + defaultConfig, err := LoadDefaultConfig() + if err != nil { + // If the file doesn't exist, use hardcoded defaults + defaultConfig = &Config{ + RqliteVersion: "8.36.11", + RqliteHttpPort: 4001, + RqliteRaftPort: 4002, + RqliteDataDir: "/home/ubuntu/data", + RqliteExtractDir: "/opt/rqlite", + NodeCPUs: 2, + NodeMemory: "2G", + NodeDisk: "10G", + DNSServers: []string{"8.8.8.8", "8.8.4.4"}, + } + } + + // Display default settings + fmt.Println("\nCurrent default settings:") + fmt.Printf("rqlite Version: %s\n", defaultConfig.RqliteVersion) + fmt.Printf("HTTP Port: %d\n", defaultConfig.RqliteHttpPort) + fmt.Printf("Raft Port: %d\n", defaultConfig.RqliteRaftPort) + fmt.Printf("Node Resources: %d CPUs, %s Memory, %s Disk\n", + defaultConfig.NodeCPUs, + defaultConfig.NodeMemory, + defaultConfig.NodeDisk) + + // Ask if user wants to use default settings + useDefaults, err := interactive.PromptConfirm("Do you want to use these default settings?") + if err != nil { + return err + } + + var config *Config + if useDefaults { + config = defaultConfig + } else { + config = defaultConfig // Start with defaults + + // Ask for each configurable value + rqliteVersion, err := interactive.PromptText("rqlite Version", config.RqliteVersion) + if err != nil { + return err + } + config.RqliteVersion = rqliteVersion + + rqliteHttpPort, err := interactive.PromptInt("HTTP Port", config.RqliteHttpPort) + if err != nil { + return err + } + config.RqliteHttpPort = rqliteHttpPort + + rqliteRaftPort, err := interactive.PromptInt("Raft Port", config.RqliteRaftPort) + if err != nil { + return err + } + config.RqliteRaftPort = rqliteRaftPort + + // Node resources + nodeCPUs, err := interactive.PromptIntWithRange("Node CPUs", config.NodeCPUs, 1, 16) + if err != nil { + return err + } + config.NodeCPUs = nodeCPUs + + nodeMemory, err := interactive.PromptText("Node Memory (e.g., 2G)", config.NodeMemory) + if err != nil { + return err + } + config.NodeMemory = nodeMemory + + nodeDisk, err := interactive.PromptText("Node Disk (e.g., 10G)", config.NodeDisk) + if err != nil { + return err + } + config.NodeDisk = nodeDisk + } + + // Save configuration to a temporary file + configPath, err := SaveConfig(config) + if err != nil { + return err + } + defer os.RemoveAll(filepath.Dir(configPath)) // Clean up temp dir when done + + // Confirm before proceeding + fmt.Println("\nReady to provision rqlite cluster with the selected settings.") + proceed, err := interactive.PromptConfirm("Do you want to proceed?") + if err != nil { + return err + } + + if !proceed { + fmt.Println("Provisioning cancelled.") + return nil + } + + // Run the provision script + fmt.Println("Running provisioning script...") + return runProvisionScript(configPath) +} + +// runProvisionScript runs the actual rqlite provisioning +func runProvisionScript(configPath string) error { + // Get path to provision script + scriptPath, err := config.GetScriptsPath("provision-rqlite.sh") + if err != nil { + return fmt.Errorf("failed to locate provision script: %w", err) + } + + // Check if script exists + if _, err := os.Stat(scriptPath); os.IsNotExist(err) { + return fmt.Errorf("provision script does not exist: %s", scriptPath) + } + + // Run the provision script with the config file + cmd := exec.Command(scriptPath) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.Stdin = os.Stdin // Pass stdin for any prompts + + return cmd.Run() +} + +// Cleanup handles rqlite cluster cleanup +func Cleanup() error { + // Get path to cleanup script + scriptPath, err := config.GetScriptsPath("cleanup-rqlite.sh") + if err != nil { + return fmt.Errorf("failed to locate cleanup script: %w", err) + } + + // Check if script exists + if _, err := os.Stat(scriptPath); os.IsNotExist(err) { + return fmt.Errorf("cleanup script does not exist: %s", scriptPath) + } + + // Run the cleanup script + cmd := exec.Command(scriptPath) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.Stdin = os.Stdin // Pass stdin for any prompts + + return cmd.Run() +} diff --git a/scripts/common-lib.sh b/scripts/common-lib.sh old mode 100644 new mode 100755 diff --git a/scripts/provision-rqlite.sh b/scripts/provision-rqlite.sh new file mode 100755 index 0000000..0744fb2 --- /dev/null +++ b/scripts/provision-rqlite.sh @@ -0,0 +1,203 @@ +#!/bin/bash +# provision-rqlite.sh - Creates and configures a rqlite environment with 3 nodes + +set -e # Exit on error + +# Set variables +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common-lib.sh" + +# rqlite VM Names +NODE1="rqlite1" +NODE2="rqlite2" +NODE3="rqlite3" + +# SSH Key paths +SSH_KEY_NAME="id_rsa_provisioning" +SSH_KEY_PATH="$HOME/.ssh/$SSH_KEY_NAME" +SSH_PUB_KEY_PATH="$SSH_KEY_PATH.pub" + +# Cloud-init and inventory paths +CLOUD_INIT_TEMPLATE="$SCRIPT_DIR/../multipass/cloud-init/common.yaml" +CLOUD_INIT_PROCESSED="$SCRIPT_DIR/../multipass/cloud-init/common_processed.yaml" +INVENTORY_FILE="$SCRIPT_DIR/../ansible/inventories/rqlite.yml" +DEFAULTS_FILE="$SCRIPT_DIR/../ansible/defaults/rqlite.yml" + +# Default resource values +NODE_CPU=2 +NODE_MEM="2G" +NODE_DISK="10G" + +# Load resource values from defaults file if it exists +if [ -f "$DEFAULTS_FILE" ] && command -v python3 >/dev/null && python3 -c "import yaml" 2>/dev/null; then + echo "Loading VM resource settings from defaults file..." + # Extract the VM resource values using Python + RESOURCES=$(python3 -c " +import yaml +try: + with open('$DEFAULTS_FILE', 'r') as f: + vars = yaml.safe_load(f) + node_cpu = vars.get('node_cpus', 2) + node_mem = vars.get('node_memory', '2G') + node_disk = vars.get('node_disk', '10G') + print(f'{node_cpu} {node_mem} {node_disk}') +except Exception as e: + print('2 2G 10G') # Default values if anything fails +") + read NODE_CPU NODE_MEM NODE_DISK <<< "$RESOURCES" + + echo "Node resources: $NODE_CPU CPUs, $NODE_MEM memory, $NODE_DISK disk" +else + echo "Using default VM resource settings" + echo "Node resources: $NODE_CPU CPUs, $NODE_MEM memory, $NODE_DISK disk" +fi + +# Check dependencies +check_dependencies || exit 1 + +# Ensure SSH key exists +ensure_ssh_key "$SSH_KEY_PATH" || exit 1 + +# Process cloud-init template +prepare_cloud_init "$CLOUD_INIT_TEMPLATE" "$CLOUD_INIT_PROCESSED" "$SSH_PUB_KEY_PATH" || exit 1 + +# Check if VMs exist +echo "Checking for existing VMs..." +NODE1_EXISTS=false +NODE2_EXISTS=false +NODE3_EXISTS=false + +if multipass info "$NODE1" &>/dev/null; then + echo -e "${GREEN}✓${NC} VM '$NODE1' exists" + NODE1_EXISTS=true +else + echo -e "${YELLOW}⚠${NC} VM '$NODE1' does not exist" +fi + +if multipass info "$NODE2" &>/dev/null; then + echo -e "${GREEN}✓${NC} VM '$NODE2' exists" + NODE2_EXISTS=true +else + echo -e "${YELLOW}⚠${NC} VM '$NODE2' does not exist" +fi + +if multipass info "$NODE3" &>/dev/null; then + echo -e "${GREEN}✓${NC} VM '$NODE3' exists" + NODE3_EXISTS=true +else + echo -e "${YELLOW}⚠${NC} VM '$NODE3' does not exist" +fi + +# Create VMs if they don't exist +if [[ "$NODE1_EXISTS" == "false" || "$NODE2_EXISTS" == "false" || "$NODE3_EXISTS" == "false" ]]; then + echo "Creating rqlite VMs with Multipass..." + echo "This may take several minutes. Please be patient..." + + # Create VMs that don't exist + if [[ "$NODE1_EXISTS" == "false" ]]; then + echo "Creating node VM: $NODE1 ($NODE_CPU CPUs, $NODE_MEM memory, $NODE_DISK disk)" + multipass launch --name "$NODE1" --cpus "$NODE_CPU" --memory "$NODE_MEM" --disk "$NODE_DISK" --cloud-init "$CLOUD_INIT_PROCESSED" + fi + + if [[ "$NODE2_EXISTS" == "false" ]]; then + echo "Creating node VM: $NODE2 ($NODE_CPU CPUs, $NODE_MEM memory, $NODE_DISK disk)" + multipass launch --name "$NODE2" --cpus "$NODE_CPU" --memory "$NODE_MEM" --disk "$NODE_DISK" --cloud-init "$CLOUD_INIT_PROCESSED" + fi + + if [[ "$NODE3_EXISTS" == "false" ]]; then + echo "Creating node VM: $NODE3 ($NODE_CPU CPUs, $NODE_MEM memory, $NODE_DISK disk)" + multipass launch --name "$NODE3" --cpus "$NODE_CPU" --memory "$NODE_MEM" --disk "$NODE_DISK" --cloud-init "$CLOUD_INIT_PROCESSED" + fi + + # Remove processed file after use + rm "$CLOUD_INIT_PROCESSED" + + # Give VMs a moment to initialize + echo "Waiting for VMs to initialize..." + sleep 15 +fi + +echo "Extracting IP addresses..." +# Extract IPs +NODE1_IP=$(multipass info "$NODE1" | grep "IPv4" | head -n 1 | awk '{print $2}') +NODE2_IP=$(multipass info "$NODE2" | grep "IPv4" | head -n 1 | awk '{print $2}') +NODE3_IP=$(multipass info "$NODE3" | grep "IPv4" | head -n 1 | awk '{print $2}') + +# Verify IPs were extracted successfully +if [ -z "$NODE1_IP" ] || [ -z "$NODE2_IP" ] || [ -z "$NODE3_IP" ]; then + echo -e "${RED}✗ Error:${NC} Failed to extract IP addresses from multipass." + echo "Please verify that VMs are running using 'multipass list'" + exit 1 +fi + +# Print the IPs to verify +echo "Node1 IP: $NODE1_IP" +echo "Node2 IP: $NODE2_IP" +echo "Node3 IP: $NODE3_IP" + +echo "Generating Ansible inventory..." +# Create directory for inventory file if it doesn't exist +mkdir -p "$(dirname "$INVENTORY_FILE")" + +# Create inventory file +cat > "$INVENTORY_FILE" << EOF +--- +all: + children: + rqlite_cluster: + children: + rqlite_leader: + hosts: + rqlite1: + ansible_host: $NODE1_IP + rqlite_followers: + hosts: + rqlite2: + ansible_host: $NODE2_IP + rqlite3: + ansible_host: $NODE3_IP + vars: + rqlite_nodes: + - rqlite1 + - rqlite2 + - rqlite3 + vars: + ansible_user: ubuntu + ansible_become: yes + ansible_ssh_private_key_file: $SSH_KEY_PATH + ansible_ssh_common_args: '-o StrictHostKeyChecking=no' +EOF + +echo -e "${GREEN}✓${NC} Ansible inventory created at $INVENTORY_FILE" + +# Verify inventory +echo "Verifying inventory file contents:" +cat "$INVENTORY_FILE" + +# Run Ansible playbook +PLAYBOOK="$SCRIPT_DIR/../ansible/playbooks/rqlite.yml" +if [ ! -f "$PLAYBOOK" ]; then + echo -e "${RED}✗ Error:${NC} Ansible playbook not found at $PLAYBOOK" + exit 1 +fi + +echo "Running Ansible playbook for rqlite deployment..." +echo "This will take some time. Please be patient..." + +if ansible-playbook -i "$INVENTORY_FILE" "$PLAYBOOK"; then + echo -e "${GREEN}✓${NC} Ansible playbook completed successfully" +else + echo -e "${RED}✗ Error:${NC} Ansible playbook failed" + exit 1 +fi + +echo -e "${GREEN}✓${NC} rqlite environment setup complete." +echo "Leader Node: $NODE1_IP:4001 (HTTP) / $NODE1_IP:4002 (Raft)" +echo "Follower Nodes: $NODE2_IP, $NODE3_IP" +echo "" +echo "To access the rqlite cluster, run:" +echo "rqlite -H $NODE1_IP" +echo "" +echo "Or from inside one of the VMs:" +echo "multipass shell $NODE1" +echo "rqlite"