.. -*- coding: utf-8 -*-

:orphan:

=========================
 Interfaces utilisateurs
=========================

Commandes salt
==============

Commandes salt
---------------

Commandes disponibles sur le *master* :

* ``salt``
* ``salt-key``
* ``salt-cp``
* ``salt-run``

Commande disponible sur le *minion* :

* ``salt-call``

salt
----

Commande principale de plotage du *master*

Mettre en conformité une machine (``top.sls``):

.. code-block:: bash

  master# salt '<machine>' state.apply

Appliquer un seul état :

.. code-block:: bash

   master# salt '<machine>' state.apply monit

**Attention** : l'ordre des options est important ::

  salt <TARGETING> [SALT OPTIONS] module.fonction [arg1 arg2]

salt - contrôle des jobs
------------------------

- Salt est un système d'exécution **asynchrone**

- La commande ``salt`` a un comportement synchrone (par défaut)

- Si vous faites un CTRL-C pendant l'exécution d'une commande ``salt``, vous obtiendrez :

.. code-block:: console

    master# salt machine state.apply
    ^CExiting on Ctrl-C
    This job's jid is:
    20150616120148025526
    The minions may not have all finished running and any
      remaining minions will return upon completion.
      To look up the return data for this job later run:
    salt-run jobs.lookup_jid 20150616120148025526

Cela n'interrompt **pas** l'exécution de la commande
``state.apply`` sur le minion, mais uniquement l'outil ``salt``
qui attendait que cette exécution se termine.

Si la commande est longue, il arrive qu'elle n'affiche rien.

En ajoutant ``-v`` à la commande, le *jid* est affiché, ainsi que les
*minions* qui n'ont pas répondu.

Il est possible de retrouver le résultat qui sera envoyé en arrière
plan au *master*.

Si vous n’avez pas utilisé ``-v`` pour afficher le ``jid``, il reste
possible d’obtenir la liste des tâches effectuées :

.. code-block:: bash

  master> salt-run jobs.list_jobs
  master> salt-run jobs.lookup_jid <job id number>
  # kill the running job
  master> salt '*' saltutil.term_job <job id number>


salt-run
--------

``salt-run`` permet d'exécuter des fonctions sur le *master*. Les
modules disponibles depuis la commande ``salt-run`` sont appelés les
*runners*.

On compte de nombreux *runners*, notamment :

* pilotage de machines virtuelles (libvirt),
* pilotage de conteneurs LXC,
* pilotage de machines physiques (IPMI, Dell DRAC),
* gestion des *jobs*,
* configuration d'un load balancer (f5)


salt-cp
-------

``salt-cp`` permet de copier un fichier du master sur des *minions* en utilisant le *targeting*::

  salt-cp '*' /tmp/myfile /tmp/distantfile


salt-call
---------

Exécute une fonction définie dans un *module* salt depuis le *minion*

Mode *masterless* :

  ``salt-call --local`` exécute la fonction comme s'il n'existait pas de *master*

Mode *debug* :

  ``salt-call --log-level all`` exécute la fonction en mode debug