Mise en place d’un cluster ScyllaDB sur AWS en utilisant Terraform

Dans cet article, je présente un exemple d’installation simple et rapide de ScyllaDB dans le cloud AWS en utilisant Terraform.

Initialement, j’avais l’intention de créer une image AMI ScyllaDB en utilisant HashiCorp Packer. Cependant, j’ai découvert plus tard que des images officielles sont disponibles, permettant à ScyllaDB d’être facilement configuré lors de l’initialisation de l’instance via les données utilisateur.

En fait, les données utilisateur peuvent définir tous les paramètres pris en charge dans scylla.yaml. Des options supplémentaires et des exemples peuvent être trouvés dans le référentiel GitHub scylla-machine-image.

Que devez-vous savoir d’autre ? Pour que ScyllaDB se configure et démarre automatiquement, des types d’instances pris en charge doivent être utilisés. Une liste de ces types d’instances peut être trouvée ici : Exigences système de ScyllaDB pour AWS. Dans notre exemple, nous utiliserons le type i4i.large car c’est le moins cher parmi les types supportés.

Hypothèses

• Un seul nœud semence est suffisant pour la configuration.
• Les hôtes sont accessibles publiquement avec un accès restreint à partir d’une adresse IP spécifique (une adresse IP publique statique est requise).

Exemple de Configuration Terraform

En suivant les bonnes pratiques, le code Terraform est divisé en plusieurs fichiers dans un seul répertoire.

Fichier de Variables (variables.tf)

variable "scylladb_version" {
  type        = string
  default     = "6.2.1"
  description = "The version of the ScyllaDB to install."
}

variable "your_public_network" {
  type        = string
  default     = "0.0.0.0/0"
  description = "Your public static IP address or your provider network."
}

variable "instance_type" {
  type        = string
  default     = "i4i.large"
  description = "The AWS instance type."
}

variable "number_of_regular_hosts" {
  type        = number
  default     = 2
  description = "The number of the regular (not seed) hosts in a cluster."
}

variable "ssh_key_name" {
  type        = string
  default     = "my_ssh_key"
  description = "The name of your public SSH key uploaded to AWS."
}

Ce fichier contient la définition des variables utilisées dans le code contenu dans main.tf. Nous en discuterons plus tard.

Fichier de Configuration Principal (main.tf)

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

# Configurer le Fournisseur AWS
provider "aws" {
  region = "eu-west-1"
}

variable "scylladb_version" {
  type        = string
  default     = "6.2.1"
  description = "The version of the ScyllaDB to install."
}

variable "your_public_network" {
  type        = string
  default     = "0.0.0.0/0"
  description = "Your public static IP address or your provider network."
}

variable "instance_type" {
  type        = string
  default     = "i4i.large"
  description = "The AWS instance type."
}

variable "number_of_regular_hosts" {
  type        = number
  default     = 2
  description = "The number of the regular (not seed) hosts in a cluster."
}

variable "ssh_key_name" {
  type        = string
  default     = "my_ssh_key"
  description = "The name of your public SSH key uploaded to AWS."
}

data "aws_ami" "scylladb_ami" {
  filter {
    name = "name"
    values = ["ScyllaDB ${var.scylladb_version}"]
  }
}

resource "aws_security_group" "scylladb_all" {
  name        = "scylladb_all"
  description = "Will allow all inbound traffic from your public IP"

  tags = {
    Name = "ScyllaDB"
  }
}

resource "aws_vpc_security_group_ingress_rule" "allow_all_inbound_traffic_ipv4" {
  security_group_id = aws_security_group.scylladb_all.id
  cidr_ipv4         = var.your_public_network
  ip_protocol       = "-1" # semantically equivalent to all ports
}

resource "aws_vpc_security_group_ingress_rule" "allow_all_internal_traffic_ipv4" {
  security_group_id            = aws_security_group.scylladb_all.id
  referenced_security_group_id = aws_security_group.scylladb_all.id
  ip_protocol                  = "-1" # semantically equivalent to all ports
}

resource "aws_vpc_security_group_egress_rule" "allow_all_traffic_ipv4" {
  security_group_id = aws_security_group.scylladb_all.id
  cidr_ipv4         = "0.0.0.0/0"
  ip_protocol       = "-1" # semantically equivalent to all ports
}

resource "aws_instance" "scylladb_seed" {
  ami           = data.aws_ami.scylladb_ami.id
  instance_type = var.instance_type
  vpc_security_group_ids = [aws_security_group.scylladb_all.id]
  key_name      = var.ssh_key_name

  user_data = <<EOF
scylla_yaml:
  cluster_name: test-cluster
  experimental: true
start_scylla_on_first_boot: true
EOF

  tags = {
    Name = "ScyllaDB seed"
  }
}

resource "aws_instance" "scylladb_host" {
  ami           = data.aws_ami.scylladb_ami.id
  instance_type = var.instance_type
  vpc_security_group_ids = [aws_security_group.scylladb_all.id]
  key_name      = var.ssh_key_name

  user_data = <<EOF
scylla_yaml:
  cluster_name: test-cluster
  experimental: true
  seed_provider:
    - class_name: org.apache.cassandra.locator.SimpleSeedProvider
      parameters:
        - seeds: ${aws_instance.scylladb_seed.private_ip}
start_scylla_on_first_boot: true
EOF

  tags = {
    Name = "ScyllaDB host"
  }

  count = var.number_of_regular_hosts
}

Le fichier main.tf décrit les ressources d’infrastructure à créer.

Fichier Décrivant les Sorties (outputs.tf)

output "scylladb_seed_public_ip" {
  value       = aws_instance.scylladb_seed.public_ip
  description = "Public IP address of the ScyllaDB seed host."
}

output "scylladb_host_public_ip" {
  value = [aws_instance.scylladb_host.*.public_ip]
  description = "Public IP addresses of ScyllaDB regular hosts."
}

Ce fichier spécifie les données à afficher à la fin. Dans notre cas, nous souhaitons connaître les adresses IP des hôtes afin de pouvoir nous y connecter.

Vous pouvez également trouver ce code sur GitHub : Exemple ScyllaDB Terraform.

Comment Utiliser Ce Fichier de Configuration Terraform

Tout d’abord, vous devez installer Terraform et AWS CLI.

L’installation de Terraform varie selon les systèmes d’exploitation. Les détails peuvent être trouvés dans la documentation officielle : Guide d’Installation de Terraform.

AWS CLI est un module Python qui peut être installé via pip de manière similaire sur tous les systèmes d’exploitation où Python est disponible. Des instructions détaillées sont disponibles dans la documentation officielle : AWS CLI sur PyPI.

La prochaine étape consiste à configurer les identifiants de sécurité pour AWS CLI. Les identifiants de sécurité peuvent être créés en utilisant le service IAM dans AWS. Nous supposons que vous les avez déjà.

Pour activer AWS CLI et, par conséquent, le fournisseur AWS pour Terraform afin d’utiliser vos informations d’identification, vous devez les configurer en utilisant la commande suivante :

aws configure

Il existe d’autres moyens de transmettre des informations d’identification à Terraform. Vous trouverez plus de détails ici : Authentification du fournisseur AWS.

Comprendre les variables

Voici un aperçu de toutes les variables :

• scylladb_version : La version de ScyllaDB, utilisée dans le nom de l’image pour rechercher l’AMI.
• your_public_network : L’adresse IP externe à partir de laquelle l’accès aux hôtes sera autorisé. Elle doit être au format CIDR (par exemple, /32 pour une seule adresse).
• instance_type : Le type d’instance AWS. Vous devez utiliser l’un des types recommandés mentionnés ci-dessus.
• number_of_regular_hosts : Le nombre d’hôtes dans le cluster, à l’exclusion de l’hôte de départ.
• ssh_key_name : Le nom de la clé SSH publique préchargée qui sera ajoutée aux hôtes.

Bien que les variables puissent être remplacées directement dans le fichier variables.tf, il est préférable d’utiliser un fichier séparé à cet effet. Il peut s’agir de n’importe quel fichier avec une extension .tfvars, tel que terraform.tfvars, situé dans le même répertoire que le fichier de configuration Terraform.

Dans un tel fichier, les variables sont écrites au format = . Par exemple :

ssh_key_name = "KEYNAME"

Comment Appliquer une Configuration Terraform

Pour créer le cluster, accédez au répertoire contenant le code et exécutez les commandes suivantes :

Initialisez le fournisseur AWS :

terraform init

Exemple de sortie :

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/aws versions matching "~> 5.0"...
- Installing hashicorp/aws v5.82.2...
- Installed hashicorp/aws v5.82.2 (signed by HashiCorp)
Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

Appliquez la configuration :

terraform apply

La sortie de la commande montrera que certains paramètres ont été pris à partir de la configuration fournie à Terraform, tandis que d’autres seront ajoutés automatiquement après l’application des changements. Confirmez l’application en tapant oui.

Après que Terraform ait terminé son travail, il affichera les adresses IP publiques des hôtes, que vous pouvez utiliser pour vous connecter à ScyllaDB.

Vérification du déploiement du cluster

Pour vérifier que le cluster ScyllaDB a été déployé avec succès, connectez-vous en SSH en utilisant la commande suivante :

ssh scyllaadm@<ip-address>

Une fois connecté, vous verrez immédiatement la liste des hôtes du cluster. Alternativement, vous pouvez exécuter la commande suivante :

nodetool status

Exemple de sortie :

Datacenter: eu-west
===================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Adresse       Charge      Jetons Possède ID Hôte                              Rack
UN 172.31.39.205 489.02 KB 256    ?    ac814131-bac5-488b-b7f8-b7201a8dbb23 1b  
UN 172.31.42.145 466.77 KB 256    ?    0bd8a16f-26d3-4665-878c-74b992b91a70 1b  
UN 172.31.46.42  526.42 KB 256    ?    3eb8966e-b42b-48c3-9938-7f24b1a6b097 1b  

Tous les hôtes doivent avoir UN (Up Normal) dans la première colonne.

Ajout d’hôtes au cluster

ScyllaDB vous permet d’ajouter facilement des hôtes aux clusters (mais pas de les supprimer). Terraform, à son tour, sauvegarde l’état de l’exécution précédente et se souvient, par exemple, de l’adresse IP de l’hôte semence. Par conséquent, vous pouvez simplement augmenter le nombre d’hôtes dans la variable et exécuter à nouveau Terraform. Le nouvel hôte rejoindra automatiquement le cluster.

Ajoutez la ligne suivante à votre fichier de variables :

number_of_regular_hosts = 3

Dans cet exemple, il ajoutera un hôte supplémentaire au cluster, mais vous pouvez définir la variable sur un nombre supérieur à 2.

Exécutez à nouveau terraform apply. Ensuite, connectez-vous à l’hôte de départ et vérifiez que la liste des hôtes a augmenté.

Gestion de plusieurs clusters

Vous pouvez déployer plusieurs clusters en utilisant une seule configuration Terraform en utilisant des espaces de travail.

Créez un nouvel espace de travail :

terraform workspace new cluster_2

cluster_2 est juste un exemple de nom pour un espace de travail. Il peut être n’importe lequel.

Déployez le nouveau cluster :

terraform apply

Le cluster d’origine restera dans l’espace de travail nommé par défaut.

Liste des espaces de travail :

terraform workspace list

Basculer entre les espaces de travail :

terraform workspace select default

Supprimer un espace de travail :

terraform workspace delete cluster_2

Destruction du cluster

Pour supprimer un cluster ScyllaDB et toutes les entités associées, utilisez la commande suivante dans l’espace de travail souhaité :

terraform destroy

Cela nettoiera toutes les ressources créées par Terraform pour ce cluster.

Conclusion

Avec ce guide, vous pouvez configurer, gérer et étendre en toute confiance les clusters ScyllaDB sur AWS en utilisant Terraform. Les instructions étape par étape fournies garantissent une expérience de déploiement sans faille, vous permettant de vous concentrer sur les performances et la scalabilité de votre application.

De plus, la flexibilité de Terraform vous permet d’adapter et de faire évoluer facilement votre cluster selon vos besoins, que ce soit en ajoutant de nouveaux hôtes ou en gérant plusieurs clusters avec des espaces de travail. Pour plus de détails et des configurations avancées, consultez la documentation officielle de Terraform et ScyllaDB, qui offrent une multitude de ressources pour vous aider à maximiser le potentiel de votre infrastructure.