introduction
Puppet est un outil de gestion de la configuration que les administrateurs système utilisent pour automatiser les processus impliqués dans la maintenance de l’infrastructure informatique d’une entreprise. L’écriture de fichiers de manifeste de marionnettes individuels est suffisante pour automatiser des tâches simples. Cependant, lorsque vous avez un flux de travail complet à automatiser, il est idéal de créer et d’utiliser un module Puppet à la place. Un module Puppet est simplement un ensemble de manifestes ainsi que les fichiers requis par ces derniers, soigneusement regroupés dans un paquet réutilisable et pouvant être partagé.
WordPress est une plateforme de blogging très populaire. En tant qu’administrateur, vous risquez souvent de devoir installer WordPress et ses dépendances (Apache, PHP et MySQL). Ce processus d’installation est un bon candidat pour l’automatisation, et nous créons aujourd’hui un module Puppet qui fait exactement cela.
Que comprend ce tutoriel?
Dans ce tutoriel, vous allez créer un module Puppet pouvant effectuer les activités suivantes:
-
Installer Apache et PHP
-
Installer MySQL
-
Créer une base de données et un utilisateur de base de données sur MySQL pour WordPress
-
Installer et configurer WordPress
Vous allez ensuite créer un manifeste simple qui utilise le module pour configurer WordPress sur Ubuntu 14.04. À la fin de ce didacticiel, vous aurez un module WordPress réutilisable et une installation WordPress fonctionnelle sur le serveur.
Conditions préalables
Vous aurez besoin des éléments suivants:
-
* Ubuntu 14.04 * serveur
-
Un utilisateur sudo
-
Vous devez comprendre comment gérer WordPress une fois la configuration du panneau de commande effectuée. Si vous avez besoin d’aide à cet égard, consultez les dernières sections de https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-on-ubuntu-14-04#step-five-%E2%80 % 94-installation-complète-via-l’interface-Web [ce tutoriel]
Étape 1 - Installez Puppet en mode autonome
Pour installer Puppet à l’aide de, le référentiel de packages de Puppet Labs doit être ajouté à la liste des référentiels disponibles. Puppet Labs a un paquet Debian qui le fait. Le nom de ce paquet dépend de la version d’Ubuntu que vous utilisez. Comme ce tutoriel utilise Ubuntu 14.04, Trusty Tahr, vous devez télécharger et installer + puppetlabs-release-trusty.deb +
.
Créez et déplacez-vous dans votre répertoire + Téléchargements +
:
mkdir ~/Downloads
cd ~/Downloads
Obtenez le paquet:
wget https://apt.puppetlabs.com/puppetlabs-release-trusty.deb
sudo dpkg -i puppetlabs-release-trusty.deb
Vous pouvez maintenant installer Puppet en utilisant + apt-get
.
sudo apt-get update
sudo apt-get install puppet
La marionnette est maintenant installée. Vous pouvez vérifier en tapant:
sudo puppet --version
Il faut imprimer la version de Puppet. Au moment d’écrire ces lignes, la dernière version est * 3.7.1 *.
-
Remarque *: Si vous voyez un message d’avertissement, vérifiez la solution à l’étape 2.
Étape 2 - Installer les modules Apache et MySQL
La gestion d’Apache et de MySQL est une activité si courante que PuppetLabs dispose de ses propres modules. Nous utiliserons ces modules pour installer et configurer Apache et MySQL.
Vous pouvez répertorier tous les modules de Puppet installés sur votre système à l’aide de la commande suivante:
sudo puppet module list
Vous ne trouverez aucun module actuellement installé.
Vous pourriez voir un message d’avertissement qui dit:
Warning: Setting templatedir is deprecated. See http://links.puppetlabs.com/env-settings-deprecations
(at /usr/lib/ruby/vendor_ruby/puppet/settings.rb:1071:in `each')
Pour supprimer cet avertissement, utilisez pour modifier le fichier et commentez la ligne:
sudo nano /etc/puppet/puppet.conf
Après les modifications, le fichier doit avoir le contenu suivant. Vous ne faites que commenter la ligne:
[main]
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$vardir/lib/facter
[master]
# These are needed when the puppetmaster is run by passenger
# and can safely be removed if webrick is used.
ssl_client_header = SSL_CLIENT_S_DN
ssl_client_verify_header = SSL_CLIENT_VERIFY
Cela devrait supprimer le message d’avertissement.
Installez les modules Apache et MySQL de PuppetLabs:
sudo puppet module install puppetlabs-apache
sudo puppet module install puppetlabs-mysql
Vérifiez l’installation en listant à nouveau les modules:
sudo puppet module list
Vous devriez pouvoir voir les modules Apache et MySQL dans la liste.
/etc/puppet/modules
├── puppetlabs-apache (v1.1.1)
├── puppetlabs-concat (v1.1.1)
├── puppetlabs-mysql (v2.3.1)
└── puppetlabs-stdlib (v4.3.2)
Étape 3 - Créer un nouveau module pour WordPress
Créez un nouveau répertoire pour conserver tous vos modules personnalisés.
mkdir ~/MyModules
cd ~/MyModules
Appelons notre module. Générez le nouveau module générique:
puppet module generate do-wordpress --skip-interview
Si vous n’incluez pas cet indicateur, la commande sera interactive et vous posera diverses questions sur le module pour remplir le fichier.
À ce stade, un nouveau répertoire nommé a été créé. Il contient du code standard et une structure de répertoire nécessaire à la construction du module.
Editez le fichier à remplacer par.
nano ~/MyModules/do-wordpress/metadata.json
Cette modification est nécessaire en raison de la présence d’un bug dans Puppet actuellement ouvert. Après le changement, votre fichier devrait ressembler à ceci:
{
"name": "do-wordpress",
"version": "0.1.0",
"author": "do",
"summary": null,
"license": "Apache 2.0",
"source": "",
"project_page": null,
"issues_url": null,
"dependencies": [
{"name":,"version_requirement":">= 1.0.0"}
]
}
Étape 4 - Créez un manifeste pour installer Apache et PHP
Utilisez pour créer et éditer un fichier nommé dans le répertoire, qui installera Apache et PHP:
nano ~/MyModules/do-wordpress/manifests/web.pp
Installez Apache et PHP avec les paramètres par défaut. Nous utilisons le MPM (Multi-Processing Module) pour optimiser la compatibilité avec d’autres bibliothèques.
Ajoutez le code suivant au fichier exactement:
class wordpress::web {
# Install Apache
class {'apache':
mpm_module => 'prefork'
}
# Add support for PHP
class {'::apache::mod::php': }
}
Étape 5 - Créer un fichier pour stocker les variables de configuration
Utilisez pour créer et éditer un fichier nommé dans le répertoire.
nano ~/MyModules/do-wordpress/manifests/conf.pp
Ce fichier est le seul endroit où vous devez définir des valeurs de configuration personnalisées, telles que des mots de passe et des noms. Tous les autres fichiers de configuration du système extrairont ses valeurs de ce fichier.
À l’avenir, si vous devez modifier la configuration Wordpress / MySQL, vous devrez modifier uniquement ce fichier.
Ajoutez le code suivant au fichier. Assurez-vous de remplacer les valeurs de la base de données par les informations personnalisées que vous souhaitez utiliser avec WordPress. Vous voudrez probablement laisser réglé sur. Vous * devriez * changer le et.
Les variables que vous pouvez ou devez modifier sont marquées dans:
class wordpress::conf {
# You can change the values of these variables
# according to your preferences
$root_password = ''
$db_name = ''
$db_user = ''
$db_user_password = ''
$db_host = ''
# Don't change the following variables
# This will evaluate to wp@localhost
$db_user_host = "${db_user}@${db_host}"
# This will evaluate to wp@localhost/wordpress.*
$db_user_host_db = "${db_user}@${db_host}/${db_name}.*"
}
Étape 6 - Créer un manifeste pour MySQL
Utilisez pour créer et éditer un fichier nommé dans le répertoire:
nano ~/MyModules/do-wordpress/manifests/db.pp
Ce manifeste a les effets suivants:
-
Installer le serveur MySQL
-
Définit le mot de passe root pour le serveur MySQL
-
Crée une base de données pour Wordpress
-
Crée un utilisateur pour Wordpress
-
Accorde des privilèges à l’utilisateur pour accéder à la base de données
-
Installe le client MySQL et les liaisons pour différentes langues
- Toutes les actions ci-dessus sont effectuées par les classes `+
-
mysql :: server` et` + :: mysql :: client`.
Ajoutez le code suivant au fichier exactement comme indiqué. Des commentaires en ligne sont inclus pour une meilleure compréhension:
class wordpress::db {
class { '::mysql::server':
# Set the root password
root_password => $wordpress::conf::root_password,
# Create the database
databases => {
"${wordpress::conf::db_name}" => {
ensure => 'present',
charset => 'utf8'
}
},
# Create the user
users => {
"${wordpress::conf::db_user_host}" => {
ensure => present,
password_hash => mysql_password("${wordpress::conf::db_user_password}")
}
},
# Grant privileges to the user
grants => {
"${wordpress::conf::db_user_host_db}" => {
ensure => 'present',
options => ['GRANT'],
privileges => ['ALL'],
table => "${wordpress::conf::db_name}.*",
user => "${wordpress::conf::db_user_host}",
}
},
}
# Install MySQL client and all bindings
class { '::mysql::client':
require => Class['::mysql::server'],
bindings_enable => true
}
}
Étape 7 - Téléchargez le dernier WordPress
Téléchargez le dernier kit d’installation de WordPress à partir du http://wordpress.org [site officiel] en utilisant et stockez-le dans le répertoire.
Créez et déplacez vers un nouveau répertoire:
mkdir ~/MyModules/do-wordpress/files
cd ~/MyModules/do-wordpress/files
Téléchargez les fichiers:
wget http://wordpress.org/latest.tar.gz
Étape 8 - Créer un modèle pour wp-config.php
Vous savez peut-être déjà que Wordpress a besoin d’un fichier contenant des informations sur la base de données MySQL qu’il est autorisé à utiliser. Un modèle est utilisé pour que Puppet puisse générer ce fichier avec les bonnes valeurs.
Créez un nouveau répertoire nommé.
mkdir ~/MyModules/do-wordpress/templates
Déplacer dans le répertoire:
cd /tmp
Extrayez les fichiers WordPress:
tar -xvzf ~/MyModules/do-wordpress/files/latest.tar.gz # Extract the tar
Le fichier que vous avez téléchargé contient un fichier. Copiez le fichier dans le répertoire en tant que.
cp /tmp/wordpress/wp-config-sample.php ~/MyModules/do-wordpress/templates/wp-config.php.erb
Nettoyez le répertoire:
rm -rf /tmp/wordpress # Clean up
Editez le fichier + wp-config.php.erb +
avec.
nano ~/MyModules/do-wordpress/templates/wp-config.php.erb
Utilisez les variables définies dans pour définir les valeurs pour,, et. Vous pouvez utiliser les paramètres exacts indiqués ci-dessous, qui extrairont vos variables réelles du fichier créé précédemment. Les éléments marqués dans sont les modifications exactes que vous devez apporter aux quatre lignes liées à la base de données.
En ignorant les commentaires, votre fichier devrait ressembler à ceci:
<?php
define('DB_NAME', '');
define('DB_USER', '');
define('DB_PASSWORD', '');
define('DB_HOST', '');
define('DB_CHARSET', 'utf8');
define('DB_COLLATE', '');
define('AUTH_KEY', 'put your unique phrase here');
define('SECURE_AUTH_KEY', 'put your unique phrase here');
define('LOGGED_IN_KEY', 'put your unique phrase here');
define('NONCE_KEY', 'put your unique phrase here');
define('AUTH_SALT', 'put your unique phrase here');
define('SECURE_AUTH_SALT', 'put your unique phrase here');
define('LOGGED_IN_SALT', 'put your unique phrase here');
define('NONCE_SALT', 'put your unique phrase here');
$table_prefix = 'wp_';
define('WP_DEBUG', false);
if ( !defined('ABSPATH') )
define('ABSPATH', dirname(__FILE__) . '/');
require_once(ABSPATH . 'wp-settings.php');
Étape 9 - Créer un manifeste pour Wordpress
Utilisez pour créer et éditer un fichier nommé dans le répertoire + manifestests +
:
nano ~/MyModules/do-wordpress/manifests/wp.pp
Ce manifeste effectue les actions suivantes:
-
Copie le contenu du kit d’installation de Wordpress dans. Cela doit être fait car la configuration par défaut d’Apache sert les fichiers de
-
Génère un fichier en utilisant le modèle
Ajoutez le code suivant au fichier exactement comme indiqué:
class wordpress::wp {
# Copy the Wordpress bundle to /tmp
file { '/tmp/latest.tar.gz':
ensure => present,
source => "puppet:///modules/wordpress/latest.tar.gz"
}
# Extract the Wordpress bundle
exec { 'extract':
cwd => "/tmp",
command => "tar -xvzf latest.tar.gz",
require => File['/tmp/latest.tar.gz'],
path => ['/bin'],
}
# Copy to /var/www/
exec { 'copy':
command => "cp -r /tmp/wordpress/* /var/www/",
require => Exec['extract'],
path => ['/bin'],
}
# Generate the wp-config.php file using the template
file { '/var/www/wp-config.php':
ensure => present,
require => Exec['copy'],
content => template("wordpress/wp-config.php.erb")
}
}
Étape 10 - Créer init.pp, un manifeste intégrant les autres manifestes
Chaque module de marionnette doit avoir un fichier nommé. Lorsqu’un manifeste externe inclut votre module, le contenu de ce fichier sera exécuté. Le module + puppet generate +
a déjà créé une version générique de ce fichier.
Éditez en utilisant * nano *:
nano ~/MyModules/do-wordpress/manifests/init.pp
Laissez le fichier avoir le contenu suivant.
Vous pouvez laisser les explications et les exemples commentés en haut. Il devrait y avoir un bloc vide pour la classe + wordpress +
. Ajoutez le contenu indiqué ici pour que le bloc + wordpress +
ressemble à celui présenté ci-dessous. Assurez-vous que les crochets sont correctement imbriqués.
Des commentaires en ligne sont inclus pour expliquer les paramètres:
class wordpress {
# Load all variables
class { 'wordpress::conf': }
# Install Apache and PHP
class { 'wordpress::web': }
# Install MySQL
class { 'wordpress::db': }
# Run Wordpress installation only after Apache is installed
class { 'wordpress::wp':
require => Notify['Apache Installation Complete']
}
# Display this message after MySQL installation is complete
notify { 'MySQL Installation Complete':
require => Class['wordpress::db']
}
# Display this message after Apache installation is complete
notify { 'Apache Installation Complete':
require => Class['wordpress::web']
}
# Display this message after Wordpress installation is complete
notify { 'Wordpress Installation Complete':
require => Class['wordpress::wp']
}
}
Étape 11 - Construire le module WordPress
Le module est maintenant prêt à être construit. Déplacez-vous dans le répertoire MyModules:
cd ~/MyModules
Utilisez la commande + puppet module build +
pour construire le module:
sudo puppet module build do-wordpress
Vous devriez voir le résultat suivant d’une construction réussie:
Notice: Building /home/user/MyModules/do-wordpress for release
Module built: /home/user/MyModules/do-wordpress/pkg/do-wordpress-0.1.0.tar.gz
Le module est maintenant prêt à être utilisé et partagé. Vous trouverez le paquet installable dans le répertoire du module.
Étape 12 - Installer le module WordPress
Pour utiliser le module, il faut d’abord l’installer. Utilisez la commande + puppet module install
.
sudo puppet module install ~/MyModules/do-wordpress/pkg/do-wordpress-0.1.0.tar.gz
Après l’installation, lorsque vous exécutez la commande + sudo puppet module list
, vous devriez voir une sortie semblable à celle-ci:
/etc/puppet/modules
├── do-wordpress (v0.1.0)
├── puppetlabs-apache (v1.1.1)
├── puppetlabs-concat (v1.1.1)
├── puppetlabs-mysql (v2.3.1)
└── puppetlabs-stdlib (v4.3.2)
Maintenant qu’il est installé, vous devez référencer ce module en tant que + do-wordpress +
pour toutes les commandes Puppet.
Mise à jour ou désinstallation du module
Si vous recevez des erreurs d’installation ou si vous remarquez des problèmes de configuration avec WordPress, vous devrez probablement apporter des modifications à un ou plusieurs fichiers du manifeste et des fichiers associés que nous avons créés précédemment dans le didacticiel.
Ou, vous pouvez simplement désinstaller le module à un moment donné.
Pour mettre à jour ou désinstaller le module, utilisez cette commande:
sudo puppet module uninstall do-wordpress
Si vous voulez simplement désinstaller, vous avez terminé.
Sinon, apportez les modifications nécessaires, puis reconstruisez et réinstallez le module conformément aux étapes 11 à 12.
Étape 13 - Utilisez le module dans un fichier manifeste autonome pour installer WordPress
Pour utiliser le module pour installer Wordpress, vous devez créer un nouveau manifeste et l’appliquer.
Utilisez pour créer et éditer un fichier nommé + install-wp.pp +
dans le répertoire (ou tout autre répertoire de votre choix).
nano /tmp/install-wp.pp
Ajoutez le contenu suivant au fichier exactement comme indiqué:
class { 'wordpress':
}
Appliquez le manifeste en utilisant + puppet apply +
. C’est l’étape qui permet à WordPress de fonctionner sur votre serveur:
sudo puppet apply /tmp/install-wp.pp
C’est bien de voir un ou deux avertissements.
L’exécution prendra un certain temps, mais à la fin, vous aurez Wordpress et toutes ses dépendances installés et en cours d’exécution.
Les quelques dernières lignes d’installation réussies devraient ressembler à ceci:
Notice: /Stage[main]/Apache/File[/etc/apache2/mods-enabled/authn_core.load]/ensure: removed
Notice: /Stage[main]/Apache/File[/etc/apache2/mods-enabled/status.load]/ensure: removed
Notice: /Stage[main]/Apache/File[/etc/apache2/mods-enabled/mpm_prefork.load]/ensure: removed
Notice: /Stage[main]/Apache/File[/etc/apache2/mods-enabled/status.conf]/ensure: removed
Notice: /Stage[main]/Apache/File[/etc/apache2/mods-enabled/mpm_prefork.conf]/ensure: removed
Notice: /Stage[main]/Apache::Service/Service[httpd]: Triggered 'refresh' from 55 events
Notice: Finished catalog run in 55.91 seconds
Vous pouvez ouvrir un navigateur et visiter http: ///. Vous devriez voir l’écran de bienvenue de WordPress.
image: https: //assets.digitalocean.com/articles/wordpress_puppet/1.png [Bienvenue dans WordPress]
À partir de là, vous pouvez configurer votre panneau de contrôle WordPress normalement.
Déploiement sur plusieurs serveurs
Si vous exécutez Puppet dans une configuration Agent-Master et souhaitez installer WordPress sur une ou plusieurs machines distantes, il vous suffit d’ajouter la ligne + class {'wordpress':} +
aux définitions * node * de ces machines. Pour en savoir plus sur la configuration Agent-Master et les définitions de noeud, vous pouvez vous référer à ce tutoriel:
Conclusion
Avec ce tutoriel, vous avez appris à créer votre propre module Puppet qui configure WordPress pour vous. Vous pouvez également en tirer parti pour ajouter la prise en charge de l’installation automatique de certains thèmes et plug-ins. Enfin, lorsque vous estimez que votre module pourrait également être utile, vous pouvez le publier sur Puppet Forge.