Quelques articles plus tôt, je vous parlais du plaisir d’utiliser vagrant pour partager et pour itérer dans mon apprentissage. C’est tellement important de pouvoir casser et refaire les choses sans se poser de questions et sans perdre de temps. C’est clairement quelque chose que je ne pouvais pas faire avec mes raspberry ou avec de simples serveurs.

Avec des machines c’est assez cools, parfois je passe par docker mais pas pour utiliser saltstack.

Alors, aujourd’hui, je vous propose de découvrir le petit vagrantfile et les scripts qui me permettent de partir à la création de tutoriels saltstack si facilement comme vous pouvez les retrouver ici.

Rien de compliqué, prenons cela dans l’ordre.

Le vagrantfile pour commencer

On va repartir de mon squelette classique. Et commencer à demander à l’utilisateur si il souhaite que l’on installe salt master et ses minions ou juste des VM vierges.

Vagrant.configure(2) do |config|

  config.cache.auto_detect = true

	saltSatckInstall = ""

  case ARGV[0]
		when "provision", "up"
    	print "Do you want to install salt Stack master/minion (y/n) ?\n"
    	saltSatckInstall = STDIN.gets.chomp
    	print "\n"
  end

Donc on a ouvert la boucle vagrant. Et surtout derrière on alimente une variable dédiée à l’installation de vagrant ou non.

  etcHosts=""
  common = <<-SHELL
  sudo apt update -qq 2>&1 >/dev/null
  sudo apt install -y -qq git vim tree net-tools telnet 2>&1 >/dev/null
  sudo echo "autocmd filetype yaml setlocal ai ts=2 sw=2 et" > /home/vagrant/.vimrc
  sed -i 's/ChallengeResponseAuthentication no/ChallengeResponseAuthentication yes/g' /etc/ssh/sshd_config
  sudo systemctl restart sshd
  SHELL

On créé une variable vide pour le moment en vue de stocker notre liste qui mettra à jour nos /etc/hosts sur chaque machine. Et on créé une variable contenant les opérations communes de bases (tooing, ssh etc).

On définie l’os que nous allons utiliser sur toute la stack (ce serait assez facile de permettre des variations pour développer sur différents OS à la fois).

# set vagrant image
	config.vm.box = "ubuntu/focal64"
	config.vm.box_url = "ubuntu/focal64"

Puis on déclare nos serveurs avec leurs ressources et leurs types.

	NODES = [
  	{ :hostname => "salt1", :ip => "192.168.123.10", :cpus => 4, :mem => 2096, :type => "master" },
  	{ :hostname => "salt2", :ip => "192.168.123.11", :cpus => 2, :mem => 2096, :type => "minion" },
  	{ :hostname => "salt3", :ip => "192.168.123.12", :cpus => 2, :mem => 2096, :type => "minion" },
  	{ :hostname => "salt4", :ip => "192.168.123.13", :cpus => 2, :mem => 2096, :type => "minion" }
	]

Easy !!!

Maintenant que l’on a notre liste on va pouvoir préparer la variable qui contient le script d’édition du /etc/hosts de chacune des machines.

  NODES.each do |node|
   	etcHosts += "echo '" + node[:ip] + "   " + node[:hostname] + "' >> /etc/hosts" + "\n"
  end #end NODES

On boucle sur la liste des serveurs et on fait un echo dans /etc/hosts, il ne reste plus qu’à jouer le script via la variable à l’installation.

  NODES.each do |node|
    config.vm.define node[:hostname] do |cfg|
			cfg.vm.hostname = node[:hostname]
      cfg.vm.network "private_network", ip: node[:ip]
      cfg.vm.provider "virtualbox" do |v|
				v.customize [ "modifyvm", :id, "--cpus", node[:cpus] ]
        v.customize [ "modifyvm", :id, "--memory", node[:mem] ]
        v.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
        v.customize ["modifyvm", :id, "--natdnsproxy1", "on"]
        v.customize ["modifyvm", :id, "--name", node[:hostname] ]
      end #end provider

On ouvre la boucle du provisionning avec les éléments assez standards d’un vagrantfile et en récupérant les éléments de notre table des noeuds.

			#for all
      cfg.vm.provision :shell, :inline => etcHosts
      cfg.vm.provision :shell, :inline => common
      if node[:type] == "master" and saltSatckInstall == "y"
        cfg.vm.provision :shell, :path => "install_master.sh"
      end
      if node[:type] == "minion" and saltSatckInstall == "y"
        cfg.vm.provision :shell, :path => "install_minion.sh"
      end

    end # end config
  end # end nodes
end 

Enfin on joue le script des variables etcHosts et common. Puis on installe le master et ensuite les minion.

Les scripts Shell d’installation de salt master et les minions

Alors la partie simple et sympa avec du bash simple comme tout pour installer saltstack sur les machines en s’adaptant.

Pour le master :

curl -sL https://bootstrap.saltstack.com -o install_salt.sh 2>&1 >/dev/null 
chmod 755 install_salt.sh
sudo sh install_salt.sh -P -M 2>&1 >/dev/null
sudo mkdir -p /home/vagrant/{salt,pillar}
sudo chown vagrant:vagrant  /home/vagrant/salt /home/vagrant/pillar

echo "
file_roots:
  base:
    - /home/vagrant/salt
    - /home/vagrant/pillar
" >> /etc/salt/master

echo "
master: 127.0.0.1
" >/etc/salt/minion

sudo systemctl restart salt-master
sudo systemctl restart salt-minion
sleep 10
sudo salt-key -A -y
sleep 5
sudo salt '*' test.ping

On bootstrap salt en mode master. On créé les répertoires de pillars et file_root. Pour cela on s’est adapté à la configuration standard d’un master salt pour le pillar_roots et le file_roots.

On configure le minion local au master. On restart le tout et on attend 10 secondes avant d’accepter toutes les clefs et on termine par un simple ping.

A ce stade on peut y faire des ajustements.

Pour les minions :

curl -sL https://bootstrap.saltstack.com -o install_salt.sh 2>&1 >/dev/null
chmod 755 install_salt.sh
sudo sh install_salt.sh -P 2>&1 >/dev/null

echo "
master: salt1
" >/etc/salt/minion

sudo systemctl restart salt-minion
sudo apt install -y sshpass
sleep 10
sshpass -p 'vagrant' ssh -o StrictHostKeyChecking=no vagrant@salt1 "sudo salt-key -A -y"

Un peu la même opération mais en plus simple. On installe un salt simple avec le script de bootstrap puis on édite le nom du master. Ensuite on restart le minion. Enfin, la dernière ligne permet d’envoyer via SSH une acceptation de toutes les clefs sur le master (la on est super large lol).

Conclusion

Vagrant c’est vraiment cool pour ce genre de chose. Comme je l’avais expliqué ce genre de scripts bash pourraient se mettre plutôt avec un provisionner ansible. Mais comme j epréfère permettre au plus grand nombre de reprendre tout ça, Bash c’est vraiment pas mal même si j’aodre ansible.

Source : Vagrantfile

Alors à vous de vous faire plaisir avec tout ça !!!

L’article Saltstack : vagrantfile avec master et minions est apparu en premier sur Xavki.