Comment construire un serveur Hashicorp Vault en utilisant Packer et Terraform sur DigitalOcean [Quickstart]

Introduction

Vault, de Hashicorp, est un outil open-source permettant de stocker en toute sécurité des secrets et des données sensibles dans des environnements cloud dynamiques. Packer et Terraform, également développés par Hashicorp, peuvent être utilisés ensemble pour créer et déployer des images de Vault.

Dans ce tutoriel, vous utiliserez Packer pour créer un instantané immuable du système avec Vault installé, et orchestrer son déploiement à l’aide de Terraform.

Pour obtenir une version plus détaillée de ce tutoriel, veuillez vous reporter à Comment construire un serveur Hashicorp Vault en utilisant Packer et Terraform sur DigitalOcean.

Conditions préalables

• Packer installé sur votre machine locale. Pour obtenir des instructions, consultez la documentation officielle.
• Terraform installé sur votre machine locale. Consultez la documentation officielle pour obtenir un guide.
• Un jeton d’accès personnel (clé API) avec des droits en lecture et en écriture pour votre compte DigitalOcean. Consultez Comment créer un jeton d’accès personnel pour en créer un.
• Une clé SSH que vous utiliserez pour vous authentifier avec les droplets Vault déployés ; elle est disponible sur votre machine locale et ajoutée à votre compte DigitalOcean. Vous aurez également besoin de l’empreinte digitale associée, que vous pourrez copier à partir de la page de sécurité de votre compte une fois que vous l’aurez ajoutée. Consultez la documentation de DigitalOcean pour obtenir des instructions détaillées, ou encore le tutoriel Comment configurer les clés SSH.

Étape 1 - Création d’un modèle Packer

Créez le répertoire ~/vault-orchestration et accédez à celui-ci pour stocker vos fichiers Vault :

mkdir ~/vault-orchestration
cd ~/vault-orchestration

Créez des répertoires distincts pour Packer et pour la configuration Terraform en exécutant :

mkdir packer terraform

Naviguez vers le répertoire Packer :

cd packer

Utilisation des variables du modèle

Créez un objet variables.json dans votre sous-répertoire packer pour stocker vos données variables privées :

nano variables.json

Ajoutez les lignes suivantes :

{
  "do_token": "your_do_api_key",
  "base_system_image": "ubuntu-18-04-x64",
  "region": "nyc3",
  "size": "s-1vcpu-1gb"
}

Vous utiliserez ces variables dans le modèle que vous êtes sur le point de créer. Vous pouvez modifier les valeurs de l’image de base, de la région et de la taille des Droplets, en fonction des developer docs.

Remplacez your_do_api_key par votre clé API, puis enregistrez et fermez le fichier.

Création de constructeurs et de fournisseurs

Créez votre modèle Packer pour Vault dans un fichier nommé template.json :

nano template.json

Ajoutez les lignes suivantes :

{
   "builders": [{
       "type": "digitalocean",
       "api_token": "{{user `do_token`}}",
       "image": "{{user `base_system_image`}}",
       "region": "{{user `region`}}",
       "size": "{{user `size`}}",
       "ssh_username": "root"
   }],
   "provisioners": [{
       "type": "shell",
       "inline": [
           "sleep 30",
           "sudo apt-get update",
           "sudo apt-get install unzip -y",
           "curl -L https://releases.hashicorp.com/vault/1.3.2/vault_1.3.2_linux_amd64.zip -o vault.zip",
           "unzip vault.zip",
           "sudo chown root:root vault",
           "mv vault /usr/local/bin/",
           "rm -f vault.zip"
       ]
}]
}

Vous définissez un constructeur digitalocean unique. Packer créera un droplet temporaire de la taille, de l’image et de la région définis en utilisant la clé API fournie.

Le provisionneur s’y connectera en utilisant SSH avec le nom d’utilisateur spécifié et exécutera séquentiellement tous les provisionneurs définis avant de créer un instantané DigitalOcean à partir du Droplet et de le supprimer.

Il est de type shell, qui va exécuter les commandes données sur la cible. Les commandes du modèle attendront 30 secondes que le système démarre, puis téléchargeront et décompresseront Vault 1.3.2. Consultez la page officielle de téléchargement de Vault afin d’obtenir la version la plus récente pour Linux.

Enregistrez et fermez le fichier.

Vérifiez la validité de votre modèle :

packer validate -var-file=variables.json template.json

Vous verrez la sortie suivante :

Output
Template validated successfully.

Étape 2 - Création de l’instantané

Construisez votre instantané avec la commande Packer build :

packer build -var-file=variables.json template.json

Vous verrez beaucoup de sorties qui ressembleront à ceci :

Output
digitalocean: output will be in this color.

==> digitalocean: Creating temporary ssh key for droplet...
==> digitalocean: Creating droplet...
==> digitalocean: Waiting for droplet to become active...
==> digitalocean: Using ssh communicator to connect: ...
==> digitalocean: Waiting for SSH to become available...
==> digitalocean: Connected to SSH!
==> digitalocean: Provisioning with shell script: /tmp/packer-shell035430322
...
==> digitalocean:   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
==> digitalocean:                                  Dload  Upload   Total   Spent    Left  Speed
  digitalocean: Archive:  vault.zip
==> digitalocean: 100 45.5M  100 45.5M    0     0   154M      0 --:--:-- --:--:-- --:--:--  153M
  digitalocean:   inflating: vault
==> digitalocean: Gracefully shutting down droplet...
==> digitalocean: Creating snapshot: packer-1581537927
==> digitalocean: Waiting for snapshot to complete...
==> digitalocean: Destroying droplet...
==> digitalocean: Deleting temporary ssh key...
Build 'digitalocean' finished.

==> Builds finished. The artifacts of successful builds are:
--> digitalocean: A snapshot was created: 'packer-1581537927' (ID: 58230938) in regions '...'

La dernière ligne contient le nom de l’instantané (tel que packer-1581537927) et son ID entre parenthèses, mis en évidence ici. Notez votre ID de l’instantané, car vous en aurez besoin à l’étape suivante.

Si le processus de construction échoue à cause d’erreurs d’API, attendez quelques minutes puis réessayez.

Étape 3 - Rédaction de la configuration de Terraform

Naviguez vers le sous-répertoire terraform :

cd ~/vault-orchestration/terraform

Créez un fichier nommé do-provider.tf pour stocker le fournisseur :

nano do-provider.tf

Ajoutez les lignes suivantes :

variable "do_token" {
}

variable "ssh_fingerprint" {
}

variable "instance_count" {
default = "1"
}

variable "do_snapshot_id" {
}

variable "do_name" {
default = "vault"
}

variable "do_region" {
}

variable "do_size" {
}

variable "do_private_networking" {
default = true
}

provider "digitalocean" {
token = var.do_token
}

Ce fichier fournit une clé API au fournisseur Digitalocean. Pour spécifier les valeurs de ces variables, vous allez créer un fichier de définitions de variables, de la même manière que Packer. Le nom de fichier doit se terminer par .tfvars ou .tfvars.json.

Enregistrez et fermez le fichier.

Créez un fichier de définitions variables :

nano definitions.tfvars

Ajoutez les lignes suivantes :

do_token         = "your_do_api_key"
ssh_fingerprint  = "your_ssh_key_fingerprint"
do_snapshot_id   = your_do_snapshot_id
do_name          = "vault"
do_region        = "nyc3"
do_size          = "s-1vcpu-1gb"
instance_count   = 1

Remplacez your_do_api_key, your_ssh_key_fingerprint et your_do_snapshot_id (l’ID de l’instantané que vous avez noté à l’étape précédente). Les paramètres do_region et do_size doivent porter les mêmes valeurs que dans le fichier de variables Packer.

Enregistrez et fermez le fichier.

Créez le fichier suivant pour stocker la configuration de déploiement de l’instantané Vault :

nano deployment.tf

Ajoutez les lignes suivantes :

resource "digitalocean_droplet" "vault" {
count              = var.instance_count
image              = var.do_snapshot_id
name               = var.do_name
region             = var.do_region
size               = var.do_size
private_networking = var.do_private_networking
ssh_keys = [
  var.ssh_fingerprint
]
}

output "instance_ip_addr" {
value = {
  for instance in digitalocean_droplet.vault:
  instance.id => instance.ipv4_address
}
description = "The IP addresses of the deployed instances, paired with their IDs."
}

Vous définissez ici une ressource unique du type digitalocean_droplet nommée vault. Vous définissez ses paramètres en fonction des valeurs des variables et ajoutez une clé SSH (en utilisant son empreinte digitale) de votre compte DigitalOcean à la ressource droplet. Vous fournissez à la console les adresses IP de toutes les instances nouvellement déployées.

Enregistrez et fermez le fichier.

Initialisez le répertoire en tant que projet Terraform :

terraform init

Vous verrez la sortie suivante :

Output
Initializing the backend...

Initializing provider plugins...

The following providers do not have any version constraints in configuration,
so the latest version was installed.

To prevent automatic upgrades to new major versions that may contain breaking
changes, it is recommended to add version = "..." constraints to the
corresponding provider blocks in configuration, with the constraint strings
suggested below.

* provider.digitalocean: version = "~> 1.14"

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Étape 4 - Déploiement de Vault à l’aide de Terraform

Testez la validité de votre configuration :

terraform validate

Vous verrez la sortie suivante :

Output
Success! The configuration is valid.

Exécutez la commande plan pour savoir ce que Terraform tentera lorsqu’il s’agira de provisionner l’infrastructure :

terraform plan -var-file="definitions.tfvars"

Le résultat sera similaire à :

Output
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.


------------------------------------------------------------------------

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create

Terraform will perform the following actions:

# digitalocean_droplet.vault[0] will be created
+ resource "digitalocean_droplet" "vault" {
  ...
  }

Plan: 1 to add, 0 to change, 0 to destroy.

------------------------------------------------------------------------

Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.

Exécutez le plan :

terraform apply -var-file="definitions.tfvars"

Le droplet se terminera et vous verrez une sortie similaire à ceci :

Output
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create

Terraform will perform the following actions:

+ digitalocean_droplet.vault-droplet

...

Plan: 1 to add, 0 to change, 0 to destroy.

...

digitalocean_droplet.vault-droplet: Creating...

...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Outputs:

instance_ip_addr = {
"181254240" = "your_new_server_ip"
}

Étape 5 - Vérification de votre droplet déployé

Exécutez ce qui suit pour vous connecter à votre nouveau droplet :

ssh root@your_server_ip

Une fois que vous êtes connecté, exécutez Vault avec :

vault

Vous verrez sa sortie “help” :

Output
Usage: vault <command> [args]

Common commands:
  read        Read data and retrieves secrets
  write       Write data, configuration, and secrets
  delete      Delete secrets and configuration
  list        List data or secrets
  login       Authenticate locally
  agent       Start a Vault agent
  server      Start a Vault server
  status      Print seal and HA status
  unwrap      Unwrap a wrapped secret

Other commands:
  audit          Interact with audit devices
  auth           Interact with auth methods
  debug          Runs the debug command
  kv             Interact with Vault's Key-Value storage
  lease          Interact with leases
  namespace      Interact with namespaces
  operator       Perform operator-specific tasks
  path-help      Retrieve API help for paths
  plugin         Interact with Vault plugins and catalog
  policy         Interact with policies
  print          Prints runtime configurations
  secrets        Interact with secrets engines
  ssh            Initiate an SSH session
  token          Interact with tokens

Conclusion

Vous disposez maintenant d’un système automatisé pour déployer Vault de Hashicorp sur les droplets DigitalOcean en utilisant Terraform et Packer. Pour commencer à utiliser Vault, vous devez l’initialiser et le configurer davantage. Pour savoir comment procéder, consultez les documents officiels.

Pour accéder à d’autres tutoriels sur l’utilisation de Terraform, consultez notre page de contenu Terraform.