Utilisation de Terraform

Dans un nouveau dossier, nous créons les fichiers de configuration Terraform suivants ; ils contiennent toutes les ressources pour créer un cluster SKS et les composants associés :

  • provider.tf spécifie la version du provider Exoscale
  • security_group.tf spécifie le security group et les règles à appliquer aux nœuds du cluster
  • cluster.tf définit la configuration du cluster
  • node_pool.tf définit le groupe de nœuds associé au cluster
  • kubeconfig.tf est utilisé pour créer un fichier kubeconfig local pour accéder au cluster
  • variables.tf définit les informations d’entrée
  • output.tf spécifie les informations à afficher en retour
terraform {
  required_providers {
    exoscale = {
      source  = "exoscale/exoscale"
      version = "~> 0.60.0"
    }
  }
}

provider "exoscale" {}
# A security group so the nodes can communicate and we can pull logs
resource "exoscale_security_group" "sg_sks_nodes" {
    name        = "sg_sks_nodes-${var.name}"
    description = "Allows traffic between sks nodes and public pulling of logs"
}

resource "exoscale_security_group_rule" "sg_sks_nodes_logs_rule" {
    security_group_id = exoscale_security_group.sg_sks_nodes.id
    type              = "INGRESS"
    protocol          = "TCP"
    cidr              = "0.0.0.0/0"
    start_port        = 10250
    end_port          = 10250
}

resource "exoscale_security_group_rule" "sg_sks_nodes_calico" {
    security_group_id      = exoscale_security_group.sg_sks_nodes.id
    user_security_group_id = exoscale_security_group.sg_sks_nodes.id
    type                   = "INGRESS"
    protocol               = "UDP"
    start_port             = 4789
    end_port               = 4789
}

resource "exoscale_security_group_rule" "sg_sks_nodes_ccm" {
    security_group_id = exoscale_security_group.sg_sks_nodes.id
    type              = "INGRESS"
    protocol          = "TCP"
    start_port        = 30000
    end_port          = 32767
    cidr              = "0.0.0.0/0"
}
resource "exoscale_sks_cluster" "sks" {
    zone           = var.zone
    name           = var.name
    version        = var.kube_version
    description    = "Demo cluster ${var.name} / ${var.zone}"
    service_level  = "starter"
    cni            = "calico"
    exoscale_ccm   = true
    exoscale_csi   = true
    metrics_server = true
}
resource "exoscale_sks_nodepool" "workers" {
    zone               = var.zone
    cluster_id         = exoscale_sks_cluster.sks.id
    name               = "workers-${var.name}"
    instance_type      = var.worker_type
    size               = var.workers_number
    security_group_ids = [exoscale_security_group.sg_sks_nodes.id]
}
resource "exoscale_sks_kubeconfig" "sks_kubeconfig" {
    cluster_id = exoscale_sks_cluster.sks.id
    zone       = exoscale_sks_cluster.sks.zone
    user   = "kubernetes-admin"
    groups = ["system:masters"]
}

resource "local_sensitive_file" "sks_kubeconfig_file" {
    filename        = "kubeconfig"
    content         = exoscale_sks_kubeconfig.sks_kubeconfig.kubeconfig
    file_permission = "0600"
}

output "sks_kubeconfig" {
    value = local_sensitive_file.sks_kubeconfig_file.filename
}
variable "kube_version" {
    description = "Version of the Kubernetes cluster"
    type        = string
    default     = ""
    # when default is an empty string, the latest kubernetes version available is used
}

variable "name" {
    description = "Name of the cluster"
    type        = string
    default     = "demo"
}

variable "workers_number" {
    description = "Number of workers in node pool"
    type        = number
    default     = 3
}

variable "worker_type" {
    type    = string
    default = "standard.medium"
}

variable "zone" {
    type    = string
    default = "ch-gva-2"
}
output "name" {
    value = var.name
}

output "zone" {
    value = var.zone
}

Ensuite, nous devons définir des variables d’environnement pour que Terraform puisse utiliser l’API Exoscale.

export EXOSCALE_API_KEY=...
export EXOSCALE_API_SECRET=...

Ensuite, nous initialisons Terraform pour qu’il obtienne la bonne version du provider.

terraform init

Nous vérifions que tout est correctement configuré, en simulant la création.

terraform plan

Ensuite, si aucune erreur n’est signalée, nous créons le cluster et les ressources associées.

terraform apply

Nous utilisons le fichier nommé “kubeconfig”, créé dans le dossier courant, pour configurer notre binaire kubectl local.

export KUBECONFIG=$PWD/kubeconfig

Ensuite, nous vérifions que nous pouvons accéder au cluster, en listant ses nœuds.

kubectl get nodes
⚠️

Une fois que vous avez terminé le workshop, n’oubliez pas de supprimer le cluster et les ressources associées avec la commande suivante :

terraform destroy