HashiCorp Boundary est une puissante solution pour gérer l'accès aux systèmes en fonction des identités des utilisateurs. Dans ce guide, nous vous expliquerons comment configurer et intégrer HashiCorp Boundary avec Terraform sur AWS. À la fin de ce tutoriel, vous disposerez d'un déploiement Boundary fonctionnel sur AWS.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Des identifiants de compte AWS
Terraform installé sur votre machine
Une connaissance de base des services et concepts AWS

Étape 1 : Mise en place de l'infrastructure

Pour créer l'infrastructure nécessaire sur AWS, nous utiliserons Terraform. Commencez par créer un nouveau répertoire pour vos fichiers Terraform et créez un fichier nommé main.tf. Ouvrez ce fichier dans votre éditeur de texte préféré et configurez le fournisseur AWS :

provider "aws" {
  region = "us-west-2" # Remplacez par votre région AWS souhaitée
}

Enregistrez le fichier et exécutez terraform init pour initialiser votre projet Terraform.

Ensuite, créez un groupe de sécurité AWS pour permettre le trafic entrant vers le contrôleur Boundary et les instances de travail. Ajoutez le code suivant à main.tf :

resource "aws_security_group" "boundary" {
  name = "boundary_sg"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 9200
    to_port     = 9200
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Étape 2: Provisionner le contrôleur Boundary

Il est maintenant temps de provisionner l'instance du contrôleur Boundary. Ajoutez le code suivant à main.tf :

resource "aws_instance" "boundary_controller" {
  ami           = "ami-0c55b159cbfafe1f0" # Remplacez par l'ID AMI AWS souhaité
  instance_type = "t2.micro"
  key_name      = "votre-paire-de-clés-ssh" # Remplacez par le nom de votre paire de clés SSH
  security_group_ids = [aws_security_group.boundary.id]

  tags = {
    Name = "boundary-controller"
  }
}

N'oubliez pas de remplacer les valeurs ami et key_name par les vôtres.

Étape 3: Provisionner le worker Boundary

Ensuite, provisionnons l'instance du worker Boundary. Ajoutez le code suivant à main.tf :

resource "aws_instance" "boundary_worker" {
  ami           = "ami-0c55b159cbfafe1f0" # Remplacez par l'ID AMI AWS souhaité
  instance_type = "t2.micro"
  key_name      = "votre-paire-de-clés-ssh" # Remplacez par le nom de votre paire de clés SSH
  security_group_ids = [aws_security_group.boundary.id]

  tags = {
    Name = "boundary-worker"
  }
}

Encore une fois, n'oubliez pas de remplacer les valeurs ami et key_name par les vôtres.

Étape 4: Configuration de Boundary

Maintenant que nos instances sont provisionnées, nous devons configurer le contrôleur et le worker Boundary. Nous utiliserons le provisionneur remote-exec de Terraform pour exécuter des commandes sur les instances.

Ajoutez le code suivant à main.tf :

provisioner "remote-exec" {
  connection {
    type        = "ssh"
    user        = "ec2-user"
    private_key = file("~/chemin-vers-votre/cle-privee.pem") # Remplacez par le chemin vers votre clé privée SSH
    host        = aws_instance.boundary_controller.public_ip
  }

  inline = [
    "sudo echo 'deb http://pkg.boundaryproject.io/apt/ any-arch main' | sudo tee /etc/apt/sources.list.d
/boundary.list",
    "curl -sS https://pkg.boundaryproject.io/apt/key.gpg | sudo apt-key add -",
    "sudo apt-get update",
    "sudo apt-get -y install boundary-controller"
  ]
}

provisioner "remote-exec" {
  connection {
    type        = "ssh"
    user        = "ec2-user"
    private_key = file("~/chemin-vers-votre/cle-privee.pem") # Remplacez par le chemin vers votre clé privée SSH
    host        = aws_instance.boundary_worker.public_ip
  }

  inline = [
    "sudo echo 'deb http://pkg.boundaryproject.io/apt/ any-arch main' | sudo tee /etc/apt/sources.list.d/boundary.list",
    "curl -sS https://pkg.boundaryproject.io/apt/key.gpg | sudo apt-key add -",
    "sudo apt-get update",
    "sudo apt-get -y install boundary-worker"
  ]
}

Assurez-vous de remplacer la valeur private_key par le chemin de votre clé privée SSH.

Étape 5: Finalisation et nettoyage

Enfin, ajoutez le code suivant à main.tf pour nettoyer les ressources lorsque vous n'en avez plus besoin :

resource "aws_key_pair" "example" {
  key_name   = "votre-paire-de-clés-ssh" # Remplacez par le nom souhaité de votre paire de clés SSH
  public_key = file("~/chemin-vers-votre/cle-publique.pub") # Remplacez par le chemin vers votre clé publique SSH
}

resource "aws_eip" "nat" {
  instance = aws_instance.boundary_controller.id # ou aws_instance.boundary_worker.id, selon votre configuration
  vpc      = true
}

resource "null_resource" "ansible" {
  provisioner "local-exec" {
    command = "ansible-playbook -i ${aws_eip.nat.public_ip}, -u ec2-user --private-key ~/chemin-vers-votre/cle-privee.pem provision.yml" # Remplacez par le chemin de votre playbook Ansible
  }

  depends_on = [
    aws_instance.boundary_controller,
    aws_instance.boundary_worker
  ]
}

// Ajoutez le code suivant si vous voulez détruire automatiquement les ressources
lifecycle {
    prevent_destroy = true // Commentez ou supprimez cette ligne pour permettre la destruction des ressources
}

Assurez-vous de remplacer les valeurs key_name, public_key, private_key, command et autres valeurs pertinentes par vos propres valeurs.

Étape 6: Déployez et exécutez Terraform

Enregistrez le fichier main.tf et, dans votre répertoire Terraform, exécutez terraform apply pour créer l'infrastructure et provisionner les instances Boundary.

Une fois le déploiement Terraform terminé, vous disposerez d'un déploiement Boundary entièrement fonctionnel sur AWS. Vous pouvez accéder aux instances du contrôleur et du worker Boundary à l'aide des adresses IP publiques affichées dans la sortie Terraform.

Conclusion

Dans ce tutoriel, nous avons expliqué comment configurer HashiCorp Boundary sur AWS à l'aide de Terraform. Nous avons provisionné l'infrastructure, configuré le contrôleur et le worker Boundary, et créé les ressources AWS nécessaires. En suivant ce guide, vous disposez désormais d'une base solide pour gérer l'accès à vos systèmes à l'aide de HashiCorp Boundary.

N'oubliez pas de gérer et sécuriser votre déploiement Boundary en suivant les bonnes pratiques, telles que l'utilisation de credentials sécurisés et la mise à jour régulière de votre système.

Bonne utilisation de Boundary !

Explorez l'intégration puissante d'un Pam avec HashiCorp Boundary.