Gestion de la configuration: topologie push versus pull

Les systèmes de gestion de configuration (CM) les plus établis comme Puppet et Chef utilisent une approche basée sur l'extraction: les clients interrogent périodiquement un maître centralisé pour les mises à jour. Certains d'entre eux proposent également une approche sans maître (donc, basée sur la poussée), mais affirment qu'elle n'est «pas destinée à la production» (Saltstack) ou «moins évolutive» (Puppet). Le seul système que je connaisse qui soit basé sur le push depuis le début est le deuxième Ansible.

Quel est l'avantage d'évolutivité spécifique d'un système basé sur la traction? Pourquoi est-il censé être plus facile d'ajouter plus de pull-masters que de push-agents?

Par exemple, agiletesting.blogspot.nl écrit:

dans un système «pull», les clients contactent le serveur indépendamment les uns des autres, de sorte que le système dans son ensemble est plus évolutif qu'un système «push»

D'autre part, Rackspace démontre qu'ils peuvent gérer des systèmes 15K avec un modèle basé sur le push.

infastructures.org écrit:

Nous ne jurons que par une méthodologie pull pour la maintenance des infrastructures, en utilisant un outil comme SUP, CVSup, un serveur rsync ou cfengine. Plutôt que d'envoyer des modifications aux clients, chaque machine cliente individuelle doit être responsable de l'interrogation du serveur Gold au démarrage, et périodiquement par la suite, pour maintenir son propre niveau de régime. Avant d'adopter ce point de vue, nous avons développé des scripts poussés basés sur ssh, rsh, rcp et rdist. Le problème que nous avons trouvé avec les commandes r (ou ssh) était le suivant: lorsque vous exécutez un script basé sur la commande r pour pousser une modification vers vos machines cibles, les chances sont que si vous avez plus de 30 hôtes cibles, l'un d'eux être à tout moment donné. Le maintien de la liste des machines mises en service devient un cauchemar. Au cours de l'écriture de code pour corriger cela, vous vous retrouverez avec du code wrapper élaboré pour traiter: les délais d'attente des hôtes morts; journalisation et nouvelle tentative d'hôtes morts; bifurquer et exécuter des travaux parallèles pour essayer de toucher de nombreux hôtes dans un délai raisonnable; et enfin détecter et empêcher l'utilisation de toutes les sockets TCP disponibles sur la machine source avec toutes les sessions rsh sortantes. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. bifurquer et exécuter des travaux parallèles pour essayer de toucher de nombreux hôtes dans un délai raisonnable; et enfin détecter et empêcher l'utilisation de toutes les sockets TCP disponibles sur la machine source avec toutes les sessions rsh sortantes. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. bifurquer et exécuter des travaux parallèles pour essayer de toucher de nombreux hôtes dans un délai raisonnable; et enfin détecter et empêcher l'utilisation de toutes les sockets TCP disponibles sur la machine source avec toutes les sessions rsh sortantes. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. et enfin détecter et empêcher l'utilisation de toutes les sockets TCP disponibles sur la machine source avec toutes les sessions rsh sortantes. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. et enfin détecter et empêcher l'utilisation de toutes les sockets TCP disponibles sur la machine source avec toutes les sessions rsh sortantes. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. Ensuite, vous avez toujours le problème d'obtenir tout ce que vous venez de faire dans les images d'installation pour tous les nouveaux hôtes à installer à l'avenir, ainsi que de le répéter pour tous les hôtes qui meurent et doivent être reconstruits demain. Après les problèmes rencontrés pour implémenter la réplication basée sur r-command, nous avons constaté que cela n'en valait pas la peine. Nous ne prévoyons pas de gérer une infrastructure avec des commandes r à nouveau, ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction. ou avec tout autre mécanisme de poussée d'ailleurs. Ils n'évoluent pas aussi bien que les méthodes basées sur l'extraction.

N'est-ce pas un problème d'implémentation au lieu d'un problème architectural? Pourquoi est-il plus difficile d'écrire un client push threadé qu'un serveur pull threadé?

Le problème avec les systèmes push est que vous devez avoir un modèle complet de l'architecture entière sur le nœud push central. Vous ne pouvez pas pousser vers une machine que vous ne connaissez pas.

Cela peut évidemment fonctionner, mais il faut beaucoup de travail pour le garder synchronisé.

En utilisant des choses comme Mcollective, vous pouvez convertir Puppet et d'autres CM en un système basé sur la poussée. Généralement, il est trivial de convertir un système pull en un système push, mais pas toujours simple d'aller dans l'autre sens.

Il y a aussi la question de la politique organisationnelle. Un système basé sur la poussée met toutes les mains de contrôle des administrateurs centraux. Il peut être très difficile de gérer la complexité de cette façon. Je pense que le problème de mise à l'échelle est un hareng rouge, l'une ou l'autre approche évolue si vous regardez simplement le nombre de clients. À bien des égards, la poussée est plus facile à l'échelle. Cependant, la configuration dynamique implique plus ou moins que vous avez au moins une version pull de l'enregistrement client.

En fin de compte, il s'agit de savoir quel système correspond au flux de travail et à la propriété de votre organisation. En règle générale, les systèmes de traction sont plus flexibles.

Dans le cas où cela intéresse quelqu'un, je suppose que je peux au moins fournir un rapport sur l'expérience utilisateur après avoir utilisé pour la première fois la capacité push d'Ansible dans le contexte de la gestion des correctifs des configurations multi-hôtes des systèmes critiques dans le cloud Amazon. Pour comprendre mes idées préconçues ou mes préjugés, je dois expliquer que j'ai une préférence pour Ruby au niveau des scripts d'automatisation et que j'ai mis en place des projets pour utiliser la configuration de marionnettes maître-agent par projet-Vpc dans le passé. Donc, mon expérience dément les préjugés passés, s'il y en avait.

Mon expérience récente a été très favorable à une poussée dynamique sur un domaine changeant de dizaines à plusieurs centaines de serveurs qui peuvent évoluer vers le haut ou vers le bas, être arrêtés et actualisés. Dans ma situation, une simple commande ad hoc Ansible 1.7 était tout ce dont j'avais besoin pour créer le patch. Cependant, compte tenu de l'efficacité de la mise en place d'un AnsibleController (sur un t2.micro) par Vpc à cet effet, à l'avenir, j'ai l'intention d'étendre la technique pour des exigences plus complexes.

Permettez-moi donc de revenir à la question posée dans ce fil: avantages et inconvénients de pousser dans un domaine en évolution dynamique.

Les hypothèses du type de domaine de serveur que je visais étaient les suivantes:

• Aucune hypothèse selon laquelle les adresses IP ou les noms d'hôte locaux générés par Amazon seraient durables - ils peuvent tous deux aller et venir
• Toutes les instances ont été créées à partir d'images de machine qui avaient déjà la possibilité de rendre l'accès ssh possible à partir d'un seul utilisateur administratif privilégié
• Pour individualiser les serveurs, et éventuellement les partitionner en groupes, selon la fonction ou selon le stade de développement (par exemple, test ou prod), cela se ferait en lançant des balises Amazon spécifiques de noms conventionnels convenus.
• Que je patcherais d'administrer les serveurs Linux et Windows séparément, avec différentes commandes ad hoc, donc simplement permettre aux connexions spécifiques à Linux d'échouer lors du contact avec un serveur Windows était parfaitement acceptable

Avec ces conditions à l'esprit, la création d'une image machine d'un AnsibleController à déposer dans de nombreux Vpcs et à configurer (avec des informations d'identification) in situ dans les comptes de serveur existants est très simple. Automatisé au sein de chaque instance créée à partir de l'image est

1. Un travail cron pour pousser le correctif vers les serveurs en cours d'exécution à intervalles réguliers afin que le domaine requis soit accessible en continu à intervalles
2. Une façon de calculer l'inventaire Ansible à chaque intervalle.

Le deuxième élément peut être rendu relativement sophistiqué si nécessaire (via la structure Info de l'inventaire Ansible). Mais si la sophistication n'est pas nécessaire, voici un exemple très simple d'un script pour calculer toutes les instances Amazon EC2 à chaque intervalle cron et diriger les résultats dans un fichier d'inventaire approprié (par exemple / etc / ansible / hosts)…

#!/bin/bash
# Assumes aws-cli/1.3.4 Python/2.6.9 Linux/3.4.73-64.112.amzn1.x86_64 or greater
# http://aws.amazon.com/releasenotes/8906204440930658
# To check yum list aws-cli
# Assumes that server is equipped with AWS keys and is able to access some or all
# instances in the account within it is running.
# Provide a list of host IPs each on a separate line
# If an argument is passed then treat it as the filename, whether local or absolute 
# path, to which the list is written

function list-of-ips {
    /usr/bin/aws ec2 describe-instances --filters '[ {"Name": "instance-state-code", "Values": [ "16" ] } ]' | grep -w PrivateIpAddress | awk  '{x=$2; gsub("\"","", x); gsub(",","", x); if(x && FNR!=1){print x;}}' | uniq
 }

if [ -n "$1" ]; then
   list-of-ips > "$1"
else
   list-of-ips
fi

La seule mise en garde pour le cas d'utilisation est que la commande patch doit être idempotente. Il est souhaitable d'effectuer un pré-test pour s'assurer parfaitement que cela est satisfait, dans le cadre de s'assurer que le patch fait exactement ce qui est prévu.

Donc, pour résumer, j'ai illustré un cas d'utilisation où la poussée dynamique est efficace contre les objectifs que je me suis fixés. Il s'agit d'une solution reproductible (dans le sens d'être encapsulée dans une image qui peut être déployée dans plusieurs comptes et régions). D'après mon expérience à ce jour, la technique de poussée dynamique est beaucoup plus facile à fournir --- et à passer à l'action --- que les alternatives disponibles dans les ensembles d'outils dont nous disposons pour le moment.