Comment créer un module de marionnettes pour automatiser l’installation de WordPress sur Ubuntu 14.04

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:

É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.

Related