Voici les étapes permettant de configurer la solution Zero trust

Serveur Boundary chez AWS

1. Déployer une instance Ubuntu Server 24.04 LTS en vous référant à ce qui est conseillé chez Hashicorp.

Dans l’exemple suivant nous allons déployé une instance m6i.large qui répond à un type de déploiement de petite taille. Si vous déployer sur Azure ou GCP, les types d’instances conseillées sont également mentionnées dans le lien.

2. Make sure that the security group associated with the instance has ports 80 (http), 443 (https), 8200 (Vault) and 9202 (Boundary Worker) open for all IPs, as well as 9201 and 9203 (Remote Boundary Worker) at your office IP address, and of course that you have SSH access to the instance from your workstation only.

3. Assigner un IP statique (adresse IP Elastic chez AWS) et créer une entrée DNS chez votre registraire pour utiliser un nom de domaine pour vous connecter à l’instance.

4. Connectez-vous à l’instance via SSH une fois l’instance déployée pour démarrer l’installation des logiciels.

Installation de Boundary Controller et Worker sur l’instance AWS

5. Le contrôleur Boundary requiert Postgres SQL il faut donc débuter par son installation

sudo apt install postgresql postgresql-contrib
sudo systemctl start postgresql.service
sudo systemctl enable postgresql.service

6. Il faut par la suite créer une base de données boundary et un utilisateur pour s’y connecter. Depuis la version 15 de Postgres il faut également ajouter une permission supplémentaire pour pouvoir créer des tables dans la base de données nouvellement créée.

sudo -i -u postgres
psql
create database boundarydb;
create user boundary with password 'password';
grant all privileges on database boundarydb to boundary;
\c boundarydb;
GRANT ALL ON SCHEMA public TO boundary;
exit
exit

7. Nous pouvons maintenant passer à l’étape d’installation de Boundary. Voici la procédure pour Ubuntu mais Boundary est également disponible pour macOS, Windows et plusieurs variantes de Linux.

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install boundary

8. Il faut par la suite créer un fichier controller.hcl dans le dossier de Boundary.

sudo vi /etc/boundary.d/controller.hcl

9. Et lui insérer les informations nécessaires. Voici un exemple de fichier, il faut au minimum ajuster la section url de la base de données si vous avez utilisez un autre utilisateur ou mot de passe que ceux mentionné plus haut ainsi que le nom de domaine ou adresse IP public de votre serveur Boundary dans la section public_cluster_addr.

# Disable memory lock: https://www.man7.org/linux/man-pages/man2/mlock.2.html
disable_mlock = true

# Controller configuration block
controller {
  # This name attr must be unique across all controller instances if running in HA mode
  name = "controller-1"
  public_cluster_addr="boundary.yourdomain.com"
  description = "First controller"

  # After receiving a shutdown signal, Boundary will wait 10s before initiating the shutdown process.
  graceful_shutdown_wait_duration = "10s"

  # Database URL for postgres. This can be a direct "postgres://"
  # URL, or it can be "file://" to read the contents of a file to
  # supply the url, or "env://" to name an environment variable
  # that contains the URL.
  database {
      url = "postgresql://boundary:password@127.0.0.1:5432/boundarydb"
  }
}

# API listener configuration block
listener "tcp" {
  # Should be the address of the NIC that the controller server will be reached on
  address = "0.0.0.0"
  # The purpose of this listener block
  purpose = "api"

  tls_disable = true

  # Uncomment to enable CORS for the Admin UI. Be sure to set the allowed origin(s)
  # to appropriate values.
  #cors_enabled = true
  #cors_allowed_origins = ["https://yourcorp.yourdomain.com", "serve://boundary"]
}

# Data-plane listener configuration block (used for worker coordination)
listener "tcp" {
  # Should be the IP of the NIC that the worker will connect on
  address = "0.0.0.0:9201"
  # The purpose of this listener
  purpose = "cluster"
}

listener "tcp" {
  # Should be the address of the NIC where your external systems'
  # (eg: Load-Balancer) will connect on.
  address = "0.0.0.0:9203"
  # The purpose of this listener block
  purpose = "ops"

  tls_disable = true
}

# Root KMS configuration block: this is the root key for Boundary
# Use a production KMS such as AWS KMS in production installs
kms "aead" {
  purpose = "root"
  aead_type = "aes-gcm"
  key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  key_id = "global_root"
}

# Worker authorization KMS
# Use a production KMS such as AWS KMS for production installs
# This key is the same key used in the worker configuration
kms "aead" {
  purpose = "worker-auth"
  aead_type = "aes-gcm"
  key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  key_id = "global_worker-auth"
}

# Recovery KMS block: configures the recovery key for Boundary
# Use a production KMS such as AWS KMS for production installs
kms "aead" {
  purpose = "recovery"
  aead_type = "aes-gcm"
  key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  key_id = "global_recovery"
}

10. Comme nous allons également utiliser ce serveur comme Worker, il faut également créer un fichier worker ou modifier le fichier existant.

sudo vi /etc/boundary.d/worker.hcl

11. Assurez-vous que les informations suivantes sont correctement configuré. Il faut s’assurer d’entrer le DNS que vous avez créé plutôt dans la section public_addr et mettre des informations dans la section tags qui permettront de différencier les différents workers.

# # Note that this is an example systemd file and is not intended to be functional as-is.
# # Full configuration options can be found at https://www.boundaryproject.io/docs/configuration/worker

 listener "tcp" {
     purpose = "proxy"
     tls_disable = true
     address = "0.0.0.0"
 }

worker {
#   # Name attr must be unique across workers
   name = "worker-aws"
#   description = "A default worker created demonstration"

#   # Workers must be able to reach controllers on :9201
   controllers = [
     "127.0.0.1",
#     "10.0.0.2",
#     "10.0.0.3",
   ]

   public_addr = "worker-aws.yourdomain.com"

   tags {
     type   = ["prod", "aws"]
     region = ["ca-central-1"]
   }
 }

# # must be same key as used on controller config# 
 kms "aead" {
     purpose = "worker-auth"
     aead_type = "aes-gcm"
     key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
     key_id = "global_worker-auth"
 }

12. La première fois que nous démarrons le contrôleur, il faut initialiser la base de données. Ceci va créer un compte qui permet d’accéder à l’interface web. Entrer la commande suivante et assurez-vous de prendre en note les informations qui s’afficheront.

sudo boundary database init -config /etc/boundary.d/controller.hcl

13. Maintenant il faut démarrer le contrôleur et le worker. Si nous voulons nous assurer de ne pas avoir à les relancer à chaque redémarrage du serveur, il est possible de créer des services. Voici la procédure pour créer le contrôleur.

sudo vi /etc/systemd/system/boundarycontroller.service

14. Entrer les informations suivantes dans le fichier :

[Unit]
Description=Boundary Controller

[Service]
Type=simple
User=root
ExecStart=/usr/bin/boundary server -config=/etc/boundary.d/controller.hcl
Restart=always

[Install]
WantedBy=multi-user.target

15. Il faut en créer un second pour le worker.

sudo vi /etc/systemd/system/boundaryworker.service

16. Entrer les informations suivantes dans le fichier :

[Unit]
Description=Boundary Worker

[Service]
Type=simple
User=root
ExecStart=/usr/bin/boundary server -config=/etc/boundary.d/worker.hcl
Restart=always

[Install]
WantedBy=multi-user.target

17. Ensuite il reste à les démarrer et à les activer au redémarrage.

sudo systemctl start boundarycontroller
sudo systemctl status boundarycontroller
sudo systemctl enable boundarycontroller
sudo systemctl start boundaryworker
sudo systemctl status boundaryworker
sudo systemctl enable boundaryworker

18. Boundary utilise son propre port mais si nous voulons sécuriser la connexion à l’aide d’un certificat SSL, il est possible de déployer un serveur web devant. Pour ce faire nous allons ici utiliser Apache combiné à Certbot pour générer un certificat SSL gratuit, mais il serait également possible d’utiliser Nginx avec un certificat acheté également.

sudo apt install apache2
sudo a2enmod proxy_http
sudo apt install certbot python3-certbot-apache

19. Une fois Apache installé il faut modifier le fichier de configuration par défaut ou en créer un nouveau avant de pouvoir installer le certificat SSL et le connecter à Boundary.

sudo vi /etc/apache2/sites-enabled/000-default.conf

20. Assurez-vous de modifier la section ServerName en fonction de votre nom de domaine et de remplacer/désactiver la section DocumentRoot par les valeurs Proxy

<VirtualHost *:80>
        # The ServerName directive sets the request scheme, hostname and port that
        # the server uses to identify itself. This is used when creating
        # redirection URLs. In the context of virtual hosts, the ServerName
        # specifies what hostname must appear in the request's Host: header to
        # match this virtual host. For the default virtual host (this file) this
        # value is not decisive as it is used as a last resort host regardless.
        # However, you must set it for any further virtual host explicitly.
        #ServerName www.example.com
ProxyPreserveHost On
ProxyRequests Off
ServerName boundary.yourdomain.com
ProxyPass / http://localhost:9200/
ProxyPassReverse / http://localhost:9200/
#       ServerAdmin webmaster@localhost
#       DocumentRoot /var/www/html

        # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
        # error, crit, alert, emerg.
        # It is also possible to configure the loglevel for particular
        # modules, e.g.
        #LogLevel info ssl:warn

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
        
        # For most configuration files from conf-available/, which are
        # enabled or disabled at a global level, it is possible to
        # include a line for only one particular virtual host. For example the
        # following line enables the CGI configuration for this host only
        # after it has been globally disabled with "a2disconf".
        #Include conf-available/serve-cgi-bin.conf
</VirtualHost>

# vim: syntax=apache ts=4 sw=4 sts=4 sr noet

21. Maintenant il reste à relancer apache et générer le certificat SSL

sudo systemctl restart apache2
sudo certbot --apache

22. Une fois que vous aurez répondu aux différentes questions, vous devriez avoir un certificat SSL de généré.

23. Il est maintenant le temps de valider que votre installation de Boundary est fonctionnel avant de passer à la prochaine étape. Connectez-vous à l’aide de votre browser internet au nom de domaine que vous avez utiliser pour générer le certificat SSL. Si l’installation du certificat SSL s’est complété correctement, vous devriez maintenant avoir accès à la page de Boundary qui vous demande de vous identifier.

24. Connectez-vous à l’aide du compte admin qui a été créé lors de l’étape de l’initiation de la base de données.

25. Lors de la création de la base de données, Boundary a créé par défaut une organisation. Vous pourrez la supprimer et en créer une nouvelle plus tard. Pour l’instant assurez-vous que votre worker est bien connecté en cliquant sur la section “Workers”

Installation de Boundary Worker sur une machine virtuelle Hyper-V

Nous allons ici considérer que vous avez déjà un serveur physique sous Windows serveur 2019 exécutant le rôle Hyper-V. Ce serveur est configuré à l’interne du réseau de votre entreprise. Il serait possible de faire le même déploiement avec un autre hyperviseur peu importe qu’il soit de type 1 ou de type 2 en autant qu’il soit sur un réseau différent de celui de votre contrôleur Boundary.

1. Récupérer le fichier d’installation d’Ubuntu Serveur 24.04 LTS si vous ne l’avez pas déjà sur votre serveur physique

2. Créer une nouvelle machine virtuelle avec au minimum un processeur ayant 2 coeurs, 8 Go de mémoire et 50Go d’espace disque.

3. Démarrer la machine virtuelle et suivez les étapes pour installer Ubuntu Server. Assurez-vous d’activer l’installation d’OpenSSH Server durant l’installation et idéalement de lui assigner une adresse IP statique ou d’effectuer une réservation sur votre serveur DHCP.

4. Connectez-vous en SSH à votre machine virtuelle une fois qu’elle est redémarrée.

5. Installer Boundary en suivant les étapes suivantes :

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install boundary

6. Créer un fichier worker

sudo vi /etc/boundary.d/worker.hcl

7. Au lieu de le connecter à 127.0.0.1, il faudra le connecter à l’adresse de votre contrôleur AWS que vous avez créé précédemment. Il faut également s’assurer d’entrer le DNS que vous avez créé plutôt dans la section public_addr et mettre des informations dans la section tags qui permettront de différencier les différents workers.

# # Note that this is an example systemd file and is not intended to be functional as-is.
# # Full configuration options can be found at https://www.boundaryproject.io/docs/configuration/worker

 listener "tcp" {
     purpose = "proxy"
     tls_disable = true
     address = "0.0.0.0"
 }

worker {
#   # Name attr must be unique across workers
   name = "worker-mainoffice"
#   description = "A default worker created demonstration"

#   # Workers must be able to reach controllers on :9201
   controllers = [
     "X.X.X.X:9201",
#     "10.0.0.2",
#     "10.0.0.3",
   ]

   public_addr = "worker-mainoffice.yourdomain.com"

   tags {
     type   = ["prod", "mainoffice"]
#     region = ["ca-central-1"]
   }
 }

# # must be same key as used on controller config# 
 kms "aead" {
     purpose = "worker-auth"
     aead_type = "aes-gcm"
     key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
     key_id = "global_worker-auth"
 }

8. Si nous voulons nous assurer de ne pas avoir à le relancer à chaque redémarrage du serveur, il est possible de créer un service.

sudo vi /etc/systemd/system/boundaryworker.service

9. Entrer les informations suivantes dans le fichier :

[Unit]
Description=Boundary Worker

[Service]
Type=simple
User=root
ExecStart=/usr/bin/boundary server -config=/etc/boundary.d/worker.hcl
Restart=always

[Install]
WantedBy=multi-user.target

10. Ensuite il reste à le démarrer et à l’activer :

sudo systemctl start boundaryworker
sudo systemctl status boundaryworker
sudo systemctl enable boundaryworker

11. Il reste maintenant à vous assurez que le 9202 est rediriger vers votre Worker Boundary dans votre routeur

12. Une fois que ce sera fait vous serez en mesure de l’utiliser via le serveur principal de Boundary. Si vous retourner dans l’interface web du serveur Boundary, vous devriez maintenant voir 2 workers s’afficher dans la liste

13. Vous pouvez déployer autant de worker que vous avez besoin en fonction du nombre de réseau interne que vous avez besoin de vous connecter. Si vous avez des serveurs avec différents fournisseurs cloud ou plusieurs bureaux physiques dans lesquelles vous avez des serveurs à gérer, vous pouvez déployer un worker à chacun de ces endroits et le connecter au contrôleur principal.

Installation de Vault

1. Si vous déployer Vault sur une instance qui a déjà Boundary d’installé, vous pouvez simplement utiliser la commande suivante en SSH pour l’installer :

sudo apt install vault

2. Si par contre vous préférez déployer Vault sur une instance séparée, vous pouvez déployer une instance Ubuntu 24.04 Server LTS en vous référant à ce qui est recommandé chez Hashicorp. Par la suite vous aurez simplement à suivre les étapes suivantes pour l’installer :

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vault

3. Nous allons par la suite modifier le fichier de configuration de Vault. Vault permet de conserver les informations de différentes façon, dans l’exemple suivant nous allons simplement les conserver dans des fichiers textes sur le disque. Si vous pensez déployer Vault en production il serait judicieux de penser utiliser une autre méthode plus sécuritaire.

sudo vi /etc/vault.d/vault.hcl

4. Modifier les informations dans le fichier afin de refléter l’emplacement de votre certificat SSL ainsi que le nom de votre domaine

ui = true
storage "file" {
  path = "/opt/vault/data"
}
listener "tcp" {
  address       = "0.0.0.0:8200"
  tls_cert_file = "/etc/letsencrypt/live/UrlOfYourServer.com/fullchain.pem"
  tls_key_file  = "/etc/letsencrypt/live/UrlOfYourServer.com/privkey.pem"
}
api_addr = "https://UrlOfYourServer.com:8200"

5. Par la suite nous pouvons créer un service

sudo vi /etc/systemd/system/vault.service

6. Ajouter les informations suivantes dans le fichier

[Unit]
Description=Vault
 
[Service]
Type=simple
User=root
ExecStart=/usr/bin/vault server -config=/etc/vault.d/vault.hcl
Restart=always
 
[Install]
WantedBy=multi-user.target

7. Démarrer, valider qu’il démarre correctement et activer le service

sudo systemctl start vault
sudo systemctl status vault
sudo systemctl enable vault

8. Vous pouvez maintenant vous connecter à la page web via le port 8200 en utilisant le dns lié au certificat SSL que vous avez utilisé.

9. Lors de la première connexion, il faudra entrer quelques informations. Entrer le chiffre 5 dans la section “Key shares”, 3 dans la section “Key threshold” et télécharger le fichier JSON qui sera créé une fois que vous allez appuyer sur “Initialize”. Pour débloquer Vault après chaque redémarrage du service il faudra entrer 3 de ces 5 clés générées.

10. Entrer le token root que vous avez reçu dans le fichier JSON pour vous connecter une fois que vous aurez mis 3 des 5 clés pour débloquer Vault.

11. L’installation de Vault est complété.

Installation d’une machine virtuelle Windows Serveur 2019

Nous allons ici considérer que vous avez déjà un serveur physique sous Windows serveur 2019 exécutant le rôle Hyper-V. Ce serveur est configuré à l’interne du réseau de votre entreprise et a déjà au minimum une machine virtuelle Windows Serveur qui est configuré comme contrôleur de domaine.

1. Créer une machine virtuelle exécutant Windows serveur 2019. Vous pourriez également utiliser Windows 11 ou toute autre version de Windows que vous avez à votre disposition.

2. Installer le système d’exploitation

3. Assurez-vous de connecter la machine virtuelle à votre domaine et d’activer la connexion RDP

4. La configuration de votre machine virtuelle est terminée

Création d’une instance Ubuntu serveur 24.04 LTS chez AWS

1. Déployer une instance Ubuntu Server 24.04 LTS chez AWS dans le même subnet que celui de votre serveur Boundary ou dans un subnet que votre serveur Boundary est idéalement en mesure de se connecter via le réseau interne d’AWS et non via le réseau public. Nous allons ici utiliser une instance t3a.medium mais si vous avez l’intention de l’utiliser comme serveur web ou autres, c’est à votre discrétion d’utiliser le type d’instance qui vous convient.

2. Assurez-vous d’utiliser une règle de sécurité qui permet à la fois à votre poste de travail de se connecter en SSH à cette instance et également à l’adresse IP interne de votre serveur Boundary.

3. Comme nous n’avons besoin que d’un accès SSH à cette instance, la configuration est terminée.