Infrastructure as Code con Hikube (legacy)

Metodo dismesso

Questo metodo gestiva Hikube tramite un kubeconfig di progetto e manifesti Kubernetes. Il kubeconfig di progetto non è più disponibile: questo metodo non funziona più. Questa pagina è conservata a titolo di riferimento.

Automazione: l'API pubblica

Per automatizzare la gestione delle sue risorse, utilizzi l'API pubblica Hikube, con chiavi API associate a un progetto; è attualmente in anteprima. È allo studio un provider Terraform dedicato, basato su questa API. Per gestire le sue risorse manualmente, utilizzi la console Hikube.

È possibile utilizzare Terraform per gestire l'infrastruttura Hikube in modo dichiarativo e riproducibile, tramite i provider Kubernetes.

---

Configurazione

Prerequisiti

• Un kubeconfig di progetto. Non è più disponibile: veda l'avviso in cima alla pagina.
• Terraform (versione >= 1.0)
• kubectl

Provider Kubernetes

main.tf

terraform {
  required_providers {
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.24"
    }
    kubectl = {
      source  = "gavinbunney/kubectl"
      version = "~> 1.14"
    }
  }
}

provider "kubernetes" {
  config_path = "~/.kube/config"
}

provider "kubectl" {
  config_path = "~/.kube/config"
}

Variabili

variables.tf

variable "ssh_public_key" {
  description = "Chiave SSH pubblica per l'accesso alle VM"
  type        = string
}

variable "cluster_name" {
  description = "Nome del cluster Kubernetes"
  type        = string
  default     = "terraform-cluster"
}

variable "vm_name" {
  description = "Nome della macchina virtuale"
  type        = string
  default     = "terraform-vm"
}

---

Esempi

Distribuire un cluster Kubernetes

kubernetes.tf

resource "kubectl_manifest" "kubernetes_cluster" {
  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "Kubernetes"
    metadata = {
      name = var.cluster_name
    }
    spec = {
      version      = "v1.34"
      storageClass = "replicated"

      controlPlane = {
        replicas = 2
      }

      nodeGroups = {
        general = {
          minReplicas      = 1
          maxReplicas      = 5
          instanceType     = "s1.large"
          ephemeralStorage = "50Gi"
          roles            = ["ingress-nginx"]
        }
        # Esempio di gruppo GPU (richiede l'addon gpuOperator qui sotto)
        # gpu = {
        #   minReplicas      = 0
        #   maxReplicas      = 4
        #   instanceType     = "u1.2xlarge"
        #   ephemeralStorage = "200Gi"
        #   gpus             = [{ name = "nvidia.com/AD102GL_L40S" }]
        #   roles            = []
        # }
      }

      addons = {
        certManager = {
          enabled = true
        }
        ingressNginx = {
          enabled = true
          hosts = [
            "${var.cluster_name}.example.com"
          ]
        }
        # Necessario per esporre le GPU ai pod di un node group GPU
        # gpuOperator = {
        #   enabled = true
        # }
      }
    }
  })
}

# Recuperare il kubeconfig
data "kubernetes_secret" "cluster_kubeconfig" {
  depends_on = [kubectl_manifest.kubernetes_cluster]
  
  metadata {
    name = "kubernetes-${var.cluster_name}-admin-kubeconfig"
  }
}

# Salvare il kubeconfig
resource "local_file" "kubeconfig" {
  content = base64decode(
    data.kubernetes_secret.cluster_kubeconfig.data["super-admin.conf"]
  )
  filename = "${path.module}/${var.cluster_name}-kubeconfig.yaml"
  file_permission = "0600"
}

Distribuire una macchina virtuale

virtual-machine.tf

# Il disco è una risorsa VMDisk distinta, referenziata dalla VM
resource "kubectl_manifest" "vm_disk" {
  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "VMDisk"
    metadata = {
      name = "${var.vm_name}-disk"
    }
    spec = {
      source = {
        image = {
          name = "ubuntu-2404"
        }
      }
      storage      = "50Gi"
      storageClass = "replicated"
    }
  })
}

resource "kubectl_manifest" "virtual_machine" {
  depends_on = [kubectl_manifest.vm_disk]

  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "VMInstance"
    metadata = {
      name = var.vm_name
    }
    spec = {
      runStrategy     = "Always"
      instanceProfile = "ubuntu"
      instanceType    = "u1.xlarge"

      disks = [
        {
          name = "${var.vm_name}-disk"
        }
      ]

      external       = true
      externalMethod = "PortList"
      externalPorts  = [22, 80, 443]

      sshKeys = [var.ssh_public_key]

      cloudInit = <<-EOT
        #cloud-config
        users:
          - name: ubuntu
            sudo: ALL=(ALL) NOPASSWD:ALL
            shell: /bin/bash
            ssh_authorized_keys:
              - ${var.ssh_public_key}
        
        package_update: true
        packages:
          - curl
          - wget
          - git
          - docker.io
        
        runcmd:
          - systemctl enable docker
          - systemctl start docker
          - usermod -aG docker ubuntu
      EOT
    }
  })
}

Distribuire una VM con GPU

vm-gpu.tf

resource "kubectl_manifest" "vm_gpu_disk" {
  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "VMDisk"
    metadata = {
      name = "gpu-vm-disk"
    }
    spec = {
      source = {
        image = {
          name = "ubuntu-2404"
        }
      }
      storage      = "100Gi"
      storageClass = "replicated"
    }
  })
}

resource "kubectl_manifest" "vm_gpu" {
  depends_on = [kubectl_manifest.vm_gpu_disk]

  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "VMInstance"
    metadata = {
      name = "gpu-vm"
    }
    spec = {
      runStrategy     = "Always"
      instanceProfile = "ubuntu"
      instanceType    = "u1.xlarge"

      gpus = [
        {
          # Modelli: nvidia.com/AD102GL_L40S, nvidia.com/GA100_A100_PCIE_80GB,
          # nvidia.com/GA100_A100_SXM4_80GB, nvidia.com/GB202GL_RTX_PRO_6000_BLACKWELL_SERVER_EDITION
          name = "nvidia.com/AD102GL_L40S"
        }
      ]

      disks = [
        {
          name = "gpu-vm-disk"
        }
      ]

      external       = true
      externalMethod = "PortList"
      externalPorts  = [22, 8888]

      sshKeys = [var.ssh_public_key]

      cloudInit = <<-EOT
        #cloud-config
        users:
          - name: ubuntu
            sudo: ALL=(ALL) NOPASSWD:ALL
            shell: /bin/bash
        
        package_update: true
        packages:
          - curl
          - wget
          - build-essential
        
        runcmd:
          # Installazione driver NVIDIA
          - wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.0-1_all.deb
          - dpkg -i cuda-keyring_1.0-1_all.deb
          - apt-get update
          - apt-get install -y cuda-toolkit nvidia-driver-535
          - nvidia-smi -pm 1
      EOT
    }
  })
}

Distribuire PostgreSQL

postgresql.tf

resource "kubectl_manifest" "postgres" {
  yaml_body = yamlencode({
    apiVersion = "apps.cozystack.io/v1alpha1"
    kind       = "Postgres"
    metadata = {
      name = "terraform-postgres"
    }
    spec = {
      external     = false
      size         = "20Gi"
      replicas     = 2
      storageClass = "replicated"
      
      users = {
        admin = {
          password = var.postgres_password
        }
      }
      
      databases = {
        myapp = {
          roles = {
            admin = ["admin"]
          }
        }
      }
    }
  })
}

variable "postgres_password" {
  description = "Password for PostgreSQL admin user"
  type        = string
  sensitive   = true
}

---

Output e variabili

Output utili

outputs.tf

output "cluster_kubeconfig" {
  description = "Percorso del kubeconfig del cluster"
  value       = local_file.kubeconfig.filename
}

output "vm_status" {
  description = "Comando per verificare lo stato della VM"
  value       = "kubectl get vminstance ${var.vm_name}"
}

output "postgres_connection" {
  description = "Comando per connettersi a PostgreSQL"
  value       = "kubectl exec -it postgres-terraform-postgres-0 -- psql -U admin -d myapp"
  sensitive   = true
}

File terraform.tfvars

terraform.tfvars

# Configurazione di base
cluster_name = "my-prod-cluster"
vm_name      = "my-app-vm"

# La sua chiave SSH pubblica
ssh_public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQ... user@hostname"

# Password PostgreSQL
postgres_password = "your-secure-password-here"

---

Buone pratiche

Struttura del progetto

hikube-terraform/
├── environments/
│   ├── dev/
│   ├── staging/
│   └── production/
├── modules/
│   ├── kubernetes/
│   ├── vm/
│   └── database/
└── shared/
    ├── variables.tf
    └── outputs.tf

Comandi utili

# Inizializzare Terraform
terraform init

# Pianificare le modifiche
terraform plan

# Applicare la configurazione
terraform apply

# Verificare le risorse create
terraform show

# Eliminare le risorse
terraform destroy

---

Riferimenti

• Provider Kubernetes
• Provider kubectl
• Documentazione Terraform