chake - En ligne dans le cloud

PROGRAMME:

Nom

chake - configuration sans serveur avec chef

INTRODUCTION

chake est un outil qui vous aide à gérer plusieurs hôtes avec, sans avoir besoin d'un chef
serveur. La configuration est gérée dans un répertoire local, qui devrait probablement se trouver sous
contrôle de version avec jet(1) ou autre chose. La configuration est généralement déployée via rsync
via SSH et appliqué en appelant chef solo(1) via SSH sur chaque hôte.

CRÉATEUR LES DÉPÔT

$ chake initialisation
[créer] nodes.yaml
[ mkdir] nodes.d/
[créer] config.rb
[ mkdir] configuration/rôles
[ mkdir] livres de cuisine/bases/recettes/
[créer] des livres de recettes/basics/recipes/default.rb
[créer] Rakefile

Une brève explication des fichiers créés :

· nodes.yaml : où vous listerez les hôtes que vous gérerez et quelles recettes utiliser
s'appliquent à chacun d'eux.

· nodes.d : un répertoire avec plusieurs fichiers au même format que nodes.yaml. Tous les fichiers
correspondant à *.yaml sera ajouté à la liste des nœuds.

· config.rb : contient la configuration chef-solo. Vous pouvez le modifier, mais généralement vous
je n’en aurai pas besoin.

· config/roles : le répertoire est l'endroit où vous pouvez mettre vos définitions de rôles.

· livres de cuisine : répertoire dans lequel vous stockerez vos livres de cuisine. Un exemple de livre de recettes intitulé
"Basics" est créé, mais n'hésitez pas à le supprimer et à ajouter de vrais livres de cuisine.

· Rakefile : contient uniquement la ligne "chake" requise. Vous pouvez l'augmenter avec d'autres tâches
spécifiques à votre infrastructure.

Une fois le référentiel créé, vous pouvez appeler chake ou rake, car ils sont complètement
équivalent.

GÉRANT NUDS

Juste après avoir créé votre dépôt, le contenu de nodes.yaml est le suivant :

host1.mycompany.com :
liste_d'exécution :
- recette[bases]

Vous pouvez lister vos hôtes avec des nœuds rake :

$ nœuds de râteau
host1.mycompany.com ssh

Pour ajouter plus de nœuds, ajoutez simplement à nodes.yaml :

host1.mycompany.com :
liste_d'exécution :
- recette[bases]
host2.mycompany.com :
liste_d'exécution :
- recettes [bases]

Et Chake connaît désormais votre nouveau nœud :

$ nœuds de râteau
host1.mycompany.com ssh
host2.mycompany.com ssh

PRÉPARATIFS NUDS À BE GÉRÉ

Les nœuds ont très peu d'exigences initiales à gérer avec chake :

· Le nœud doit être accessible via SSH.

· L'utilisateur que vous connectez au nœud doit être soit root, soit être autorisé à exécuter sudo (dans
auquel cas sudo doit être installé).

A noter on Mot de passe instructions: chaque fois que Chake appelle ssh sur un nœud, vous devrez peut-être
saisissez votre mot de passe ; chaque fois que chake appelle sudo sur le nœud, vous devrez peut-être taper
dans votre mot de passe. Pour gérer un ou deux nœuds, c'est probablement bien, mais pour les plus grands
nombre de nœuds, ce n’est pas pratique. Pour éviter les invites de mot de passe, vous pouvez :

· Configurez l'authentification basée sur la clé SSH. C'est plus sécurisé que d'utiliser des mots de passe.
Pendant que vous y êtes, vous souhaitez probablement aussi désactiver l'authentification par mot de passe
complètement et autoriser uniquement l'authentification par clé

· Configurez l'accès sudo sans mot de passe pour l'utilisateur que vous utilisez pour vous connecter à vos nœuds.

VÉRIFICATION CONNECTIVITÉ ET INITIALE HÔTE SETUP

Pour vérifier si les hôtes sont correctement configurés, vous pouvez utiliser la tâche de vérification :

Chèque de commission en $

Cela exécutera la commande sudo true sur chaque hôte. Si ça passe sans que tu aies à le faire
mots de passe, vous êtes sûr que

· vous disposez d'un accès SSH à chaque hôte ; et

· L'utilisateur avec lequel vous vous connectez a correctement configuré sudo sans mot de passe.

Chèque de commission en $

APPLIQUER LIVRES DE CUISINE

Pour appliquer la configuration à tous les nœuds, exécutez

$ rake converge

Pour appliquer la configuration à un seul nœud, exécutez

$ rake converge :$NODE

Pour appliquer une seule recette sur tous les nœuds, exécutez

$ rake appliquer[ma recette]

Pour appliquer une seule recette sur un nœud spécifique, exécutez

$ rake apply:$NODE[marecette]

Si vous ne renseignez pas de recette dans la ligne de commande, vous serez invité à en indiquer une.

Pour exécuter une commande shell sur tous les nœuds, exécutez

$ rake run[commande]

Si la commande que vous souhaitez exécuter contient des espaces ou d'autres caractères spéciaux, faites-le
le shell, il faut les citer.

Pour exécuter une commande shell sur un nœud spécifique, exécutez

$ rake run:$NODE[commande]

Si vous ne renseignez pas de commande dans la ligne de commande, vous serez invité à en saisir une.

Pour vérifier les tâches existantes, exécutez

$ râteau -T

L'ÉCRITURE LIVRES DE CUISINE

Puisque chake est en fait un wrapper pour Chef Solo, vous devriez lire la [documentation du chef](
).
En particulier, consultez la [Documentation Chef Solo]( <https://docs.chef.io/
chef_solo.html>).

LES NODE AMORÇAGE PROCESSUS

Lorsque chake agit sur un nœud pour la première fois, il doit l'amorcer. Le bootstrap
le processus comprend les opérations suivantes :

· installer chef et rsync

· désactiver le démon client chef

· configuration du nom d'hôte

NODE URL

Les clés du hachage représenté dans nodes.yaml sont une URL de nœud. Tous les composants de
l'URL mais le nom d'hôte sont facultatifs, donc la simple liste des noms d'hôte est la forme la plus simple de
en spécifiant vos nœuds. Voici tous les composants des URL des nœuds :

[backend://][nom d'utilisateur@]nom d'hôte[:port][/chemin]

· backend : backend à utiliser pour se connecter à l'hôte. ssh ou local (par défaut : ssh)

· nom d'utilisateur : nom d'utilisateur avec lequel se connecter (par défaut : le nom d'utilisateur sur votre poste de travail local)

· nom d'hôte : le nom d'hôte auquel se connecter (par défaut : aucun)

· port : numéro de port auquel se connecter (par défaut : 22)

· /path : où stocker les livres de recettes au niveau du nœud (par défaut : /var/tmp/chef.$USERNAME)

EXTRA CARACTERISTIQUES

# HOOKS

Vous pouvez définir des tâches de rake qui seront exécutées avant l'amorçage des nœuds, avant
télécharger le contenu de gestion de la configuration sur les nœuds, et avant la convergence. Pour faire ça,
il vous suffit d'enrichir les tâches correspondantes :

· bootstrap_common : exécuté avant l'amorçage des nœuds (même si les nœuds ont déjà été
amorcé)

· upload_common : exécuté avant de télécharger le contenu sur le nœud

· converge_common : exécuté avant la convergence (c'est-à-dire exécuter le chef)

Mise en situation :

tâche :bootstrap_common faire
sh './scripts/pre-bootstrap-checks'
fin

# Crypté DES DOSSIERS

Tous les fichiers se terminant par correspondant .gpg et .asc seront déchiffrés avec GnuPG avant d'être envoyés à
le nœud. Vous pouvez les utiliser pour stocker des mots de passe et d'autres informations sensibles (clés SSL,
etc) dans le référentiel avec le reste de la configuration.

# DÉPÔT-LOCAL SSH CONFIGURATION

Si vous avez besoin de paramètres de configuration SSH spéciaux, vous pouvez créer un fichier appelé .ssh_config
(ou quel que soit le nom de fichier que vous avez dans la variable d'environnement $CHAKE_SSH_CONFIG, voir ci-dessous
pour plus de détails) à la racine de votre référentiel, et chake l'utilisera lors de l'appel de ssh.

# Journalisation IN À A HÔTE

Pour vous connecter facilement à l'un de vos hôtes, exécutez simplement rake login:$HOSTNAME. Cette volonté
utilisez automatiquement la configuration SSH locale du référentiel comme ci-dessus afin que vous n'ayez pas à le faire
tapez -F .ssh_config tout le temps.

# RUNNING TOUTES SSH INVOCATIONS WITH CERTAINS PRÉFIXE COMMAND

Parfois, vous souhaiterez ou devrez également préfixer vos invocations SSH avec un préfixe
commande afin par ex. tunnelez-le via un nœud de sortie central. Vous pouvez le faire en
en définissant $CHAKE_SSH_PREFIX sur votre environnement. Exemple:

CHAKE_SSH_PREFIX=le râteau des tsocks converge

Ce qui précède fera que toutes les invocations SSH vers tous les hôtes seront appelées comme tsocks ssh [...]

# CONVERGENT L'APPROVISIONNEMENT HÔTE

Si vous souhaitez gérer votre poste de travail local avec chake, vous pouvez déclarer un nœud local comme
ceci dans nodes.yaml :

local://coup de tonnerre :
liste_d'exécution :
- rôle[poste de travail]

Pour appliquer la configuration à l'hôte local, vous pouvez utiliser le rake conventionnel
converse:thunderbolt, ou le râteau cible spécial local.

Lors de la convergence de tous les nœuds, chake ignorera les nœuds déclarés avec local://
backend et dont le nom d'hôte ne correspond pas au nom d'hôte dans la déclaration. Par exemple:

local://bureau :
liste_d'exécution :
- rôle[poste de travail]
local://ordinateur portable :
liste_d'exécution :
- rôle[poste de travail]

Lorsque vous exécutez Rake Convergence sur un ordinateur de bureau, l'ordinateur portable sera ignoré, et vice versa.

ENVIRONNEMENT VARIABLES

· $CHAKE_SSH_CONFIG : fichier de configuration SSH local. La valeur par défaut est .ssh_config.

· $CHAKE_SSH_PREFIX : commande pour préfixer les appels SSH (et rsync sur SSH) avec.

· $CHAKE_RSYNC_OPTIONS : options supplémentaires à transmettre à rsync. Utile par ex. exclure les grands
les fichiers ne sont pas téléchargés sur chaque serveur.

· $CHAKE_NODES : Fichier contenant la liste des serveurs à gérer. Par défaut : nodes.yaml.

· $CHAKE_NODES_D : Répertoire contenant les serveurs de fichiers de définition de nœud à gérer.
Par défaut : nodes.d.

· $CHAKE_TMPDIR : Répertoire utilisé pour stocker les fichiers de cache temporaires. Par défaut : tmp/chake.

· $CHAKE_CHEF_CONFIG : fichier de configuration Chef, relatif à la racine du référentiel.
Par défaut : config.rb.

Utilisez chake en ligne en utilisant les services onworks.net