Administration système

Fabric

Fabric est une bibliothèque pour simplifier les tâches d’administration du système. Alors que Chef et Puppet ont tendance à se concentrer sur la gestion des serveurs et des bibliothèques du système, Fabric est plus concentré sur des tâches au niveau des applications telles que le déploiement.

Installer Fabric:

$ pip install fabric

Le code suivant va créer deux tâches que nous pouvons utiliser: memory_usage et deploy. La première va retourner l’utilisation de la mémoire sur chaque machine. La dernière va se connecter en ssh sur chaque serveur, faire un cd dans notre répertoire de projet, activer l’environnement virtuel, faire un pull de la base de code la plus récente et redémarrer le serveur d’applications.

from fabric.api import cd, env, prefix, run, task

env.hosts = ['my_server1', 'my_server2']

@task
def memory_usage():
    run('free -m')

@task
def deploy():
    with cd('/var/www/project-env/project'):
        with prefix('. ../bin/activate'):
            run('git pull')
            run('touch app.wsgi')

Avec le code précédent enregistré dans un fichier nommé fabfile.py, nous pouvons vérifier l’utilisation de la mémoire avec:

$ fab memory_usage
[my_server1] Executing task 'memory'
[my_server1] run: free -m
[my_server1] out:              total     used     free   shared  buffers   cached
[my_server1] out: Mem:          6964     1897     5067        0      166      222
[my_server1] out: -/+ buffers/cache:     1509     5455
[my_server1] out: Swap:            0        0        0

[my_server2] Executing task 'memory'
[my_server2] run: free -m
[my_server2] out:              total     used     free   shared  buffers   cached
[my_server2] out: Mem:          1666      902      764        0      180      572
[my_server2] out: -/+ buffers/cache:      148     1517
[my_server2] out: Swap:          895        1      894

et nous pouvons déployer avec:

$ fab deploy

Des fonctionnalités additionnelles incluent l’exécution en parallèle, l’interaction avec les programmes à distance, et le regroupement d’hôtes.

Salt

Salt est un outil de gestion d’infrastructure open source. Il supporte l’exécution de commandes à distance à partir d’un point central (hôte maître) à plusieurs hôtes (minions). Il supporte également des états système qui peuvent être utilisés pour configurer plusieurs serveurs à l’aide de fichiers modèle simples.

Salt supporte les versions de Python 2.6 et 2.7 et peut être installé via pip:

$ pip install salt

Après avoir configuré un serveur maître et un n’importe quel nombre d’hôtes de minion, nous pouvons exécuter des commandes shell arbitraires ou utiliser des modules pré-intégrés de commandes complexes sur nos minions.

La commande suivante liste tous les hôtes de minion disponibles, en utilisant le module ping.

$ salt '*' test.ping

Le filtrage de l’hôte est accompli en faisant correspondre l’identifiant du minion, ou en utilisant le système de grains. Le système grains utilise des informations d’hôte statique comme la version du système d’exploitation ou de l’architecture du processeur pour fournir une taxonomie d’hôte pour les modules Salt.

La commande suivante liste tous les minions disponibles exécutant CentOS, en utilisant le système grains.

$ salt -G 'os:CentOS' test.ping

Salt propose également un système d’état. Les états peuvent être utilisés pour configurer les hôtes de minion.

Par exemple, quand un hôte de minion est commandé de lire le fichier d’état suivant, il va installer et démarrer le serveur Apache:

apache:
  pkg:
    - installed
  service:
    - running
    - enable: True
    - require:
      - pkg: apache

Les fichiers d’état peuvent être écrit en utilisant le YAML, le système de template Jinja2 ou du Python pur.

Psutil

Psutil est une interface pour différentes informations système (par exemple, le CPU, la mémoire, les disques, le réseau, les utilisateurs et les processus).

Voici un exemple pour être au courant de la surcharge d’un serveur. Si l’un des tests (net, CPU) échoue, il va envoyer un e-mail.

# Functions to get system values:
from psutil import cpu_percent, net_io_counters
# Functions to take a break:
from time import sleep
# Package for email services:
import smtplib
import string
MAX_NET_USAGE = 400000
MAX_ATTACKS = 4
attack = 0
counter = 0
while attack <= MAX_ATTACKS:
    sleep(4)
    counter = counter + 1
    # Check the cpu usage
    if cpu_percent(interval = 1) > 70:
        attack = attack + 1
    # Check the net usage
    neti1 = net_io_counters()[1]
    neto1 = net_io_counters()[0]
    sleep(1)
    neti2 = net_io_counters()[1]
    neto2 = net_io_counters()[0]
    # Calculate the bytes per second
    net = ((neti2+neto2) - (neti1+neto1))/2
    if net > MAX_NET_USAGE:
        attack = attack + 1
    if counter > 25:
        attack = 0
        counter = 0
# Write a very important email if attack is higher than 4
TO = "you@your_email.com"
FROM = "webmaster@your_domain.com"
SUBJECT = "Your domain is out of system resources!"
text = "Go and fix your server!"
BODY = string.join(("From: %s" %FROM,"To: %s" %TO,"Subject: %s" %SUBJECT, "",text), "\r\n")
server = smtplib.SMTP('127.0.0.1')
server.sendmail(FROM, [TO], BODY)
server.quit()

Une application complète dans le terminal similaire à une version de ‘top’ très étendue, basée sur psutil et avec une capacité de monitoring client-serveur est glance.

Ansible

Ansible est un outil d’automatisation système open source. Le plus grand avantage sur Puppet ou Chef est qu’il ne nécessite pas un agent sur la machine cliente. Les playbooks sont la configuration, le déploiement, et le langage d’orchestration d’Ansible. Ils sont rédigés en YAML avec Jinja2 pour le templating.

Ansible supporte les versions 2.6 et 2.7 de Python et peut être installé via pip:

$ pip install ansible

Ansible nécessite un fichier inventory qui décrit les hôtes auxquels il a accès. Voici ci-dessous un exemple d’un hôte et d’un playbook qui va faire un ping sur tous les hôtes dans le fichier inventory.

Voici un exemple de fichier inventory : hosts.yml

[server_name]
127.0.0.1

Voici un exemple de playbook: ping.yml

---
- hosts: all

  tasks:
    - name: ping
      action: ping

Pour exécuter le playbook:

$ ansible-playbook ping.yml -i hosts.yml --ask-pass

Le playbook Ansible fera un ping sur tous les serveurs dans le fichier hosts.yml. Vous pouvez également sélectionner des groupes de serveurs utilisant Ansible. Pour plus d’informations sur Ansible, lisez la documentation Ansible <http://docs.ansible.com/> _.

An Ansible tutorial est aussi une bonne introduction, bien détaillée, pour commencer avec Ansible.

Chef

Chef est un framework d’automatisation système et infrastructure cloud qui rend facile de déployer des serveurs et des applications à tout emplacement physique, virtuelle ou dans le cloud. Dans le cas où c’est votre choix pour la gestion de la configuration, vous utiliserez principalement Ruby pour écrire votre code d’infrastructure.

Les clients Chef s’exécutent sur chaque serveur qui fait partie de votre infrastructure et ceux-ci vérifient régulièrement avec votre serveur Chef pour assurer que votre système est toujours aligné et représente l’état désiré. Étant donné que chaque serveur possède son propre client Chef distinct, chaque serveur se configure lui-même et cette approche distribuée fait de Chef une plate-forme d’automatisation évolutive.

Chef fonctionne en utilisant des recettes personnalisées (éléments de configuration), implémentés dans des cookbooks. Les cookbooks, qui sont essentiellement des paquets pour des choix d’infrastructure, sont généralement stockés dans votre serveur Chef. Lisez la série de tutoriels de Digital Ocean sur Chef pour apprendre comment créer un Serveur Chef simple.

Pour créer un cookbook simple, la commande knife est utilisée:

knife cookbook create cookbook_name

Getting started with Chef est un bon point de départ pour les débutants en Chef. De nombreux cookbooks maintenus par la communauté qui peuvent servir comme une bonne référence ou personnalisés pour servir vos besoins de configuration de infrastructure peuvent être trouvés sur le Supermarket Chef.

Puppet

Puppet est un logiciel de gestion de configuration et d’automatisation de Puppet Labs qui permet aux administrateurs système de définir l’état de leur infrastructure informatique, fournissant ainsi une manière élégante de gérer leur flotte de machines physiques et virtuelles.

Puppet est disponible à la fois en variante Open Source et Entreprise. Les modules sont de petites unités de code partageables écrites pour automatiser ou définir l’état d’un système. La forge Puppet est un dépôt pour les modules écrits par la communauté pour Puppet Open Source et Entreprise.

Les agents de Puppet sont installés sur des nœuds dont l’état doit être contrôlé ou changé. Un serveur désigné connu comme le Puppet Master est responsable de l’orchestration de l’agent des nœuds.

L’agent des nœuds envoie des facts de base à propos du système comme le système d’exploitation, le kernel, l’adresse ip, le nom d’hôte, etc. au Puppet Master. Le Puppet Master ensuite compile un catalogue avec les informations fournies par les agents sur comment chaque nœud doit être configuré et l’envoie à l’agent. L’agent applique le changement comme prescrit dans le catalogue et renvoie un rapport au Puppet Master.

Facter est un outil intéressant qui est livré avec Puppet qui récupère des facts de base sur le système. Ces facts peuvent être référencés comme une variable tout en écrivant vos modules Puppet.

$ facter kernel
Linux
$ facter operatingsystem
Ubuntu

L’écriture des modules dans Puppet est assez simple. Les manifestes Puppet forment ensemble les modules Puppet. Les manifestes Puppet se terminent avec une extension .pp. Voici un exemple de ‘Hello World’ en Puppet.

notify { 'This message is getting logged into the agent node':

    #As nothing is specified in the body the resource title
    #the notification message by default.
}

Voici un autre exemple avec une logique basée sur le système. Notez comment le fact du système d’exploitation est utilisé comme une variable préfixé avec le signe $. De même, cela vaut pour d’autres facts tels que le nom d’hôte qui peut être référencé par $hostname

notify{ 'Mac Warning':
    message => $operatingsystem ? {
        'Darwin' => 'This seems to be a Mac.',
        default  => 'I am a PC.',
    },
}

Il existe plusieurs types de ressources pour Puppet, mais le paradigme package-fichier-service est tout ce qu’il faut pour entreprendre la majorité de la gestion de la configuration. Le code Puppet suivant s’assure que le paquet OpenSSH-Server est installé dans un système et le service sshd est averti de redémarrer chaque fois que le fichier de configuration de sshd est modifié.

package { 'openssh-server':
    ensure => installed,
}

file { '/etc/ssh/sshd_config':
    source   => 'puppet:///modules/sshd/sshd_config',
    owner    => 'root',
    group    => 'root',
    mode     => '640',
    notify   =>  Service['sshd'], # sshd will restart
                                  # whenever you edit this
                                  # file
    require  => Package['openssh-server'],

}

service { 'sshd':
    ensure    => running,
    enable    => true,
    hasstatus => true,
    hasrestart=> true,
}

Pour plus d’informations, se référer à la Documentation Puppet Labs

Blueprint

À faire

Ecrire à propos de Blueprint

Buildout

Buildout est un outil de build logiciel open source. Buildout est créé en utilisant le langage de programmation Python. Il implémente un principe de séparation de configuration à partir des scripts qui font la configuration. Buildout est principalement utilisé pour télécharger et configurer des dépendances dans le format eggs Python du logiciel en cours de développement ou déployé. Les recettes pour des tâches de build dans tous les environnements peuvent être créés, et beaucoup sont déjà disponibles.

Buidout est écrit en Python.