Transformer un drupal7 mono-site en multi-site avec des sous-répertoires

Voici la manière de transformer un drupal monosite en drupal multisite, sous la forme :

http://www.monsite.fr qui devient http://www.monsite.fr/site1 et http://www.monsite.fr/site2
(et non pas http://site1.monsite.fr et http://site2.monsite.fr – autre cas qui n’est pas traité ici).

1/ La conf d’apache
après le « DocumentRoot » du serveur :
Alias /site1 /var/www/drupalroot
Alias /site2 /var/www/drupalroot

bien entendu, il faut mettre le bon répertoire, celui qui pointe sur la racine de Drupal

2/ le fichier .htaccess dans /var/www/drupalroot
# site1 site
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} ^/site1/(.*)$
RewriteRule ^(.*)$ /site1/index.php [L,QSA]

# site2 site
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} ^/site2/(.*)$
RewriteRule ^(.*)$ /site2/index.php [L,QSA]

# default site
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} !=/favicon.ico
RewriteRule ^ index.php [L]

3/ le répertoire « sites »
à la racine de drupal faire:

cd sites
mv default localhost.site1
mkdir localhost.site2
ln -s localhost.site1 site1
ln -s localhost.site2 site2
cd site2
mkdir files
cp ../site1/settings.php
cp ../site1/default.settings.php
chmod 777 files settings.php

cd .  #la racine de Drupal
ln -s . site2
ln -s . site1

4/ le fichier sites.php
ici c’est un peu étrange, mais c’est « Drupal » :  http://www.monsite.fr/site2 et  http://www.monsite.fr/site1 doivent s’écrire  www.monsite.fr.site1 et  www.monsite.fr.site2
On enlève le http, et le / devient un .

<?php
$sites = array(
"www.monsite.fr.site1" => "site1",
"www.monsite.fr.site2" => "site2",
);

changer le base_url dans sites/site1/settings.php
$base_url = ‘https://www.monsite.fr/site1‘;

A ce stade l’ancien site doit fonctionner sous la nouvelle URL, mais le nouveau n’est pas encore prêt

5/ création de la nouvelle base
créer une nouvelle base de donnée vierge : site2_dev

6/ fichiers sites/site2/settings.php

$base_url = ‘https://www.monsite.fr/site2‘;
$databases = array (
'default' =>
array (
'default' =>
array (
'database' => 'site2_dev',

(Attention, dans le cas présent, on est en multibase, d’ou les 2 ‘default’ qui s’enchainent)

7/ installer drupal pour créer la base
https://www.monsite.fr/site2/install.php
suivre les étapes « bêtement ».

Sinon on peut tenter un drush :

drush si ftv_site1_back --notify -y --db-url=mysql://$username$:$password$@localhost/site2_dev --account-mail=admin@local.host --account-name=admin --account-pass=$passwordadmindrupal$

et voila ! normalement à ce stade, vous avez un copie du site fonctionnellement, sans données dedans.

Drupal duel : Drupal 7&8 side by side

Voici, mis cote à cote 2 modules hello-world en Drupal 7 et Drupal 8 (beta9) qui mettent en œuvre les concepts principaux qu’on retrouve dans la plupart des modules :

  • menus et chemins d’accès
  • création de block
  • création d’un formulaire
  • theming
  • accès aux « variables »

Comme vous pouvez le constater, les changements sont nombreux, mais au final :

  • c’est la même chose écrit différement (pour simplifier : on passe du fonctionnel à de l’objet)
  • si on omet les « namespaces », ce n’est pas foncièrement plus verbeux, mais le code est éclaté en 7 fichiers en Drupal8 au lieu de 3
Drupal7 Drupal8

hello.info

hello.info.yml

name = Hello world
description = Minimalist Hello World in Drupal 7
package = Example modules
core = 7.x
files[] = hello.module
name: Hello World
type: module
description: Minimalist Hello World in Drupal 8
package: Example modules
core: 8.x

hello.module

function hello_menu() {

hello.links.menu.yml

$items['helloworld'] = array(
  'title' => 'Hello world',
hello.main:
  title: Hello world
  route_name: hello.world
$items['admin/config/content/hello'] = array(
  'title' => 'Hello config',
hello.form:
  title: Hello config
  route_name: hello.form

hello.routing.yml

$items['helloworld'] = array(
  'page callback' => '_page_hello_world',
  'access callback' => TRUE,
hello.world:
  path: 'helloworld'
  defaults:
    _controller: '\Drupal\hello\Controller\HelloRouteController::index'
  requirements:
    _access: 'TRUE'
$items['admin/config/content/hello'] = array(
  'page callback' => 'drupal_get_form',
  'page arguments' => array('hello_config_form'),
  'access arguments' => array('access hello content')
hello.form:
  path: 'admin/config/content/hello'
  defaults:
    _form: '\Drupal\hello\Form\HelloForm'
  requirements:
    _permission: 'access hello content'
function hello_theme() {
  return array(
    'hello_text' => array(
    'template' => 'hello-text',
    'variables' => array('text' => NULL)),
  );
}
function hello_theme() {
  return array(
    'hello_text' => array(
    'template' => 'hello-text',
    'variables' => array('text' => NULL)),
  );
}

src/Controller/HelloRouteController.php

function _page_hello_world() {
  return array( '#markup' => '<p>Hello world page text</p>' );
}
namespace Drupal\hello\Controller;
use Drupal\Core\Controller\ControllerBase;
class HelloRouteController extends ControllerBase {
  public function index() {
    return array('#markup' => '<p>Hello world page text</p>');
  }
}

src/Plugin/Block/HelloBlock.php

function hello_block_info() {
  $blocks['hello'] = array(
    'info' => t('Hello world block title'),
  );
  return $blocks;
}
namespace Drupal\hello\Plugin\Block;
use Drupal\Core\Block\BlockBase;
use Drupal\block\Annotation\Block;
use Drupal\Core\Annotation\Translation;
use Drupal\Core\Session\AccountInterface;
/**
* Provides a 'Hello' block.
* @Block(
* id = "hello_block",
* admin_label = @Translation("Hello world block title")
* )
*/
function hello_block_view($delta = '') {
  switch ($delta) {
    case 'hello':
      $block['subject'] = t('Hello world');
      $block['content'] = theme('hello_text', array('text' => 
        variable_get('hello_value', 'hello')));
      break;
  }
  return $block;
}
class HelloBlock extends BlockBase {
  public function build() {
    return array('#theme' => 'hello_text', '#text' =>
      \Drupal::config('hello.settings')->get('hello_value'));
  }
}

src/Form/HelloForm.php

function hello_config_form() {
namespace Drupal\hello\Form;
use Drupal\Core\Form\FormInterface;
use Drupal\Core\Form\FormBase;
use Drupal\Core\Form\FormStateInterface;
class HelloForm extends FormBase {
  public function getFormID() {
    return 'hello_form';
  }
  public function buildForm(array $form, 
    FormStateInterface $form_state) {
  $form['hello_config'] = array(
    '#type' => 'textfield',
    '#title' => t('Who are you ?'),
    '#size' => 10,
    '#description' => t('Text for the hello world block.'),
    '#default_value' => 
       variable_get('hello_value', 'anonymous'),
  );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save'),
  );
  return $form;
}
  $form['hello_config'] = array(
    '#type' => 'textfield',
    '#title' => t('Who are you ?'),
    '#size' => 10,
    '#description' => t('Text for the hello world block.'),
    '#default_value' => 
       \Drupal::config('hello.settings')->get('hello_value'),
  );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save'),
  );
  return $form;
}
function hello_config_form_submit($form, $form_state) {
  variable_set('hello_value', 
    $form_state['values']['hello_config']);
}
public function submitForm(array &$form, 
  FormStateInterface $form_state) {
  $form_values = $form_state->getValues();
  \Drupal::service('config.factory')->getEditable('hello.settings')
->set('hello_value', $form_values['hello_config'])
->save();
}

drupal7-hello-world/hello-text.tpl.php

Hi from template : <?php print $variables['text']; ?>
Hi from template : {{ text }}

 

Wolfram Language : affaire à suivre

Après Mathematica, Wolfram Alpha (le moteur de recherche qui comprends les questions), après « A New Kind of Science » et son approche empirique et systématique des automates cellulaires, Wolfram Langage impressionne !!!

  • Syntaxe simple, à la Rebol/Lisp/4th/Logo.
  • Connection a Wolfram Alpha, et donc à un Big Data universel
  • Cloud, déployable, parallélisable (sur une ferme de RPi par exemple)

Cela semble être le GRAAL des programmeurs, toutes les meilleurs idées regroupées en un seul langage. Seul défaut, il n’est pas open-source.

En quelques lignes on peut calculer le plus court trajet pour parcourir les capitales Européennes, demander l’heure de couché du soleil locale, générer des graphes interactifs, etc…

Pourquoi et comment se former à Drupal ?

Pourquoi ?

J’ai la chance d’avoir la double casquette de chef de projet et formateur Drupal.

J’ai pu constater « de visu » les dégâts que peuvent faire de mauvaises pratiques sur un développement Drupal.

Par exemple, j’ai du intervenir en tant que consultant sur un projet ou l’on me demandait comment rajouter une fonctionnalité au site. Tout naturellement, j’ai conseillé d’installer un module (la manière de choisir ou pas un module est un autre sujet) qui répondait suffisamment bien à la demande. Mais là, je me suis rendu compte que le reste du site était développé de manière « non drupaliene » et que le module ne serait pas compatible avec le site.

Il ne faut pas sous-estimer la réticence des développeurs à apprendre un nouveau framework :

  • d’abord c’est un effort considérable, un investissement, qui n’est pas toujours perçu comme rentable (à juste titre parfois);
  • ensuite, il y a les goûts et les couleurs. Les choix techniques d’un framework ne sont pas toujours parfait, ni bien justifiés;
  • connaître une API c’est une chose, mais connaître les limites d’un framework, savoir contourner et anticiper les problèmes, ça demande énormément d’expérience, voire de la passion. C’est parfois plus simple de développer les choses soi même;
  • parfois aussi, Drupal n’est pas le meilleur choix, et le développeur en connaît un plus efficace (tout du moins partiellement, mais ça peut être suffisant pour ne pas avoir envie de s’investir)

Donc, les développeurs se forment parfois à contre-coeur, ou mal, ou n’ont pas le temps de le faire correctement. En tant que formateur, il faut en tenir compte. Les conséquences de l’absence de formation sont parfois (souvent) bien plus importantes que les 3 jours qu’on « perds » à les suivre.

Le ROI d’une formation sur un produit comme Drupal est très rapide.

Comment ?

Le rôle d’un formateur est multiple, mais en premier lieu il s’agit de :

  • s’assurer que tous les concepts de bases sont assimilés
  • donner un maximum d’autonomie aux stagiaires

Il faut donc une pédagogie adaptée à ce contexte (ce sera l’objet d’un prochain article – notez qu’il risque d’y avoir des bouleversement pour Drupal 8 qui sera assez différent à enseigner). Il faut être capable d’expliquer les forces et faiblesses de Drupal, et l’intérêt de s’investir dedans. Mais il faut surtout être capable de transmettre, non pas un maximum d’informations, mais un maximum de savoir-faire !

C’est pareil dans tous les domaines. Dans le bâtiment, ce qui à de la valeur, ce n’est pas de montrer comment jeter du crépît sur un mûr et passer la taloche dessus. Ce qui à de la valeur, c’est le petit geste qu’on à mis des années à affiner et qui fait qu’on se fatigue moins, qu’on est plus précis, et au final, qu’on travaille 2X plus vite qu’un débutant. Ce n’est pas la proportion théorique de sable / ciment / eau qu’il faut pour faire du béton, mais le coup d’oeil dans la bétonnière pour savoir s’il est suffisamment gras ou pas.

Tous les développeurs savent lire et peuvent de débrouiller avec une documentation, ou un « Pro Drupal Developpment« . Le formateur doit être capable d’aller à l’essentiel, de faire le tri dans la masse d’informations pour ne retenir que les plus pertinentes. Un formateur doit donc proposer une plus-value réelle.

Pour cela, il n’y a pas 10 000 solutions : il doit s’adapter à ses stagiaires. Mes formations ne sont jamais les même, car j’élabore le programme en amont, mais aussi pendant la formation, pour coller au mieux au besoin réel. Avec des programmeurs expérimentés on va pouvoir aller dans sujets plus ardus que les API de base, ou bien, je leur tends des pièges ou leur proposes défis afin de toujours les maintenir en tension, et intéressés, de sorte qu’ils en retirent un maximum de choses (quelque soit leur niveau initial).

Une formation n’est pas un bourrage de crâne d’une liste, la plus longue possible, d’API à connaître par coeur. C’est tout l’inverse. Il s’agit d’expliquer comment Drupal est construit autour de concepts imbriqués les uns les autres et de leurs variantes. Comme ça, quand le développeur est face à une situation qu’il ne connaît pas, il sait s’orienter et trouver des solutions par lui même.

D’une certaine manière, on peut dire qu’une formation ne sert pas à savoir écrire du code, mais à le lire.

Compte rendu : Drink & Drupal Toulouse décembre 2013

Hier soir, j’ai fait une présentation de Drupal Commons 3.5 lors du Drink & Drupal à la cantine à Toulouse.

Je mettrais les slides en ligne bientôt.

DrinknDrupal1

Ambiance très sympa.

Nous en avons profité pour faire un petit test rapide de « talky.io« , une plateforme dont le code est en partie Open Source de webconférence basée sur WebRTC.

C’était assez fun de passer en webcam alors qu’on était tous dans la même pièce. Ceci dit, tout le monde a été d’accord sur l’intérêt d’intégrer cette technologie (ou une autre telle que Google Hangout – avec l’avantage que la session se retrouve archivée pour le public) lors des prochaines présentations, de sorte que d’autres puissent être de la partie, même s’ils sont loin ou indisponibles.

Nous en avons profité pour faire un point de fin d’année et voir comment organiser l’année qui arrive. Il a été retenu notamment de prévoir les conférences plus en amont, sur un calendrier glissant de 3 mois, et d’être plus présent sur drupalfr (notamment d’y poster nos présentations).

Méthodologie d’audit d’un site Drupal

Éléments à fournir pour l’audit du code :

  • fichiers sources du site

  • base de données du site

  • documentation fonctionnelle et technique

Démarche suivie :

Afin d’obtenir une vue d’ensemble du site, les étapes suivantes ont été observées :

  1. Recherche de la présence d’erreurs critiques remontées par les différents logs.

  2. Étude des modules coeur et contributeurs activés, recherche de hacks dans leurs fichiers.

  3. Examen du code des modules développés spécifiquement

  4. Examen du theme du site

Détails des contrôles effectués lors de ces étapes :

  • contrôle du rapport général de Drupal

  • contrôle du watchdog de Drupal

  • différentiel entre les fichiers du coeur de Drupal et le coeur du site à versions égales (annexe diff-modules-core)

  • différentiel entre les fichiers des modules contributeurs de Drupal et ceux du site à versions égales (annexe diff-modules-contrib)

  • utilisation du module drupal « hacked » pour recouper les informations avec les résultats des différentiels (voir annexe rapport-hacked)

  • examen des hacks détectés par les différentiels et de leur impact sur le site

  • vérification des modules activés et non-activés (voir stats)

  • vérification manuelle du code custom, combiné avec une vérification avec le module « coder »

  • examen du theme du site (voir annexe templates-pages)

En cas de mauvaises pratiques http://drupal.org/best-practices/do-not-hack-core il faut en évaluer les implications.

Notez qu’en cas de modification du cœur de Drupal ou d’un module cela va entraîner des difficultés lors de mises à jour de sécurités (qui vont écraser ces moficiations). Il est donc important de les repérer en amont.

Il faut éventuellement prévoir une campagne de revue du code et de conversion en hook_xxx_alter qui sont prévus pour éviter ce genre de situation. De manière pro-active il est conseillé de faire suivre à ses développeurs une formation, ou une micro-formation à distance, pour s’assurer qu’ils connaissent les bonnes pratiques, ou bien de faire valider les compétences du prestataire en charge du développement par un expert pour éviter ce genre de déboires à l’avenir.

Les problèmes détectés pendant l’audit sera classifiés de la manière suivante :

  • Problème : Description du problème.
  • Importance : critique, haute, moyenne
  • Type : sécurité, maintenabilité, évolutivité
  • Conséquences : description des conséquences selon le problème rencontré, les impacts pour les développeurs, les utilisateurs, les chefs de projets, et les clients
  • Solution : quelles actions mettre en œuvre pour corriger, les plus simplement possible le problème
  • Source : référence vers la documentation correspondante, le cas échéant

Evolution de la complexité cyclomatique de Drupal 4 à 8

Voici les données brutes, l’analyse viendra plus tard.

Je les aies obtenues avec la commande suivante (en paramètre je passe le n° de version de Drupal :

phploc "drupal$1" --log-csv="~/drupal-analisys/d$1loc3.csv" --names="*.php,*.inc,*.module,*.yml"
Drupal 4 Drupal 5 Drupal 6 Drupal 7 Drupal 8
Directories 7 37 40 88 1 474
Files 73 83 179 382 6 025
Lines of Code (LOC) 39 397 46 223 71 710 207 763 812 817
Cyclomatic Complexity / Lines of Code 0,45 0,45 0,46 0,42 0,22
Comment Lines of Code (CLOC) 9 261 11 631 22 255 70 845 278 700
Non-Comment Lines of Code (NCLOC) 30 136 34 592 49 455 136 918 534 117
Logical Lines of Code (LLOC) 10 808 12 112 17 086 33 566 174 481
Namespaces 0 0 0 3 1 110
Interfaces 0 0 0 16 498
Traits 0 0 0 0 10
Classes 0 0 1 110 5 223
Abstract Classes 0 0 0 10 340
Concrete Classes 0 0 1 100 4 883
Average Class Length (LLOC) 0,00 0,00 57,00 40,04 26,33
Methods 0 0 4 1 042 28 246
Non-Static Methods 0 0 4 993 25 711
Static Methods 0 0 0 49 2 535
Public Methods 0 0 4 797 22 438
Non-Public Methods 0 0 0 245 5 808
Average Method Length (LLOC) 0,00 0,00 14,25 4,23 4,87
Cyclomatic Complexity / Number of Methods 0,00 0,00 5,25 2,64 2,06
Functions 1 337 1 468 2 024 4 211 3 957
Named Functions 1 337 1 468 2 024 4 211 3 568
Anonymous Functions 0 0 0 0 389
Constants 91 110 165 267 837
Global Constants 91 110 165 258 71
Class Constants 0 0 0 9 766
Attribute Accesses 2 617 2 905 3 849 7 361 50 386
Non-Static Attribute Accesses 2 617 2 905 3 849 7 294 49 357
Static Attribute Accesses 0 0 0 67 1 029
Method Calls 1 0 1 6 795 103 543
Non-Static Method Calls 1 0 1 6 636 95 186
Static Method Calls 0 0 0 159 8 357
Global Accesses 1 067 1 183 1 483 2 846 1 481
Global Variable Accesses 263 222 252 355 447
Super-Global Variable Accesses 230 229 277 426 294
Global Constant Accesses 574 732 954 2 065 740
Test Classes 0 0 0 0 0
Test Methods 0 0 0 0 0

Quelle version de Drupal est supportée + gestion de la compatibilité ascendante ?

Pour un DSI, un site se gère sur la longueur. Il doit minimiser le fardeau de la maintenance et des évolutions tout en assurant sa pérennité maximale.

Deux problématiques principaux se posent à lui par rapport au cycle de vie du produit qu’il à choisi : les corrections de bug et les mises à jour de sécurité d’une part et la gestion de la compatibilité ascendante d’autre part.

Pour Drupal la politique est la suivante. Les  nouvelles releases sont numérotés par 2 chiffres : une version majeure, et une version mineure. Par exemple actuellement nous sommes en Drupal 7.24

  • les changements de version majeure brisent la compatibilité ascendante mais permettent des évolutions fonctionnelles et d’API majeures. Si on veut monter en version il faut donc le prévoir en amont.
  • les changements de version mineures apportent surtout des corrections de bugs, des patch de sécurités, et des évolutions mineurs, mais surtout, ne brisent pas la compatibilité ascendante. On peut donc (et c’est même recommandé pour des questions de sécurité) faire ces mise à jour « les yeux fermés » (idéalement, car dans la pratique il faut quand même prendre des précautions élémentaires).
  • La communauté supporte la version n-1. C’est à dire que Drupal 6 ne sera supporté que jusqu’à la sortie de Drupal 8.

Mais les difficultés de développement de Drupal 8, ainsi que l’évolution rapide de web imposent de revoir cette politique. Même si ce n’est pas encore définitif, il semble que la communauté Drupal s’achemine vers une nouvelle manière de gérer le cycle de vie de Drupal, dite, « release sémantique« .

De quoi s’agit-il ?

  • Les évolutions « mineures » (celles qui ne brisent pas ou très peu la compatibilité ascendante) de Drupal se feront selon un cycle de 6 mois, afin de pouvoir intégrer plus rapidement les nouveautés dans le cœur.
  • Les évolutions « majeures » (celles qui brisent la compatibilité ascendante) disposeront d’un support LTS assuré en version n-1 pour les correction de bugs et en version n-2 pour les patchs de sécurité, mais uniquement à partir de la dernière évolution mineure.

Dans la pratique cela devrait permettre un cycle de vie d’un site d’environ 5 ans avec une fenêtre d’un peu plus d’un an pour faire évoluer son site en version n+2. Ce qui semble assez raisonnable comme compromis.

Les montées en version de Drupal ne sont pas sans poser de problèmes. Il y a 4 aspects à considérer :

  • le coeur de Drupal en principe dispose d’un « chemin d’upgrade » qui fait évoluer la base de donnée afin que le site soit toujours fonctionnel
  • les thèmes (l’habillage) est à revoir en grande partie. D’une part parce que les API changent, d’autre part pour s’adapter aux nouveaux standards du web en la matière.
  • pour les modules communautaires, c’est au cas par cas. Les plus populaires disposent en général d’un chemin d’upgrade comme le coeur de Drupal, mais c’est loin d’être une règle générale. Il faut donc s’attendre devoir faire évoluer les données en base soi même, avec des requêtes SQL.
  • reste ensuite le code custum. Plus il sera important en proportion, plus l’opération sera lourde et risquée.

Le cas de Drupal 8 est la encore différent. Il n’y aura pas de « chemin d’upgrade » depuis Drupal 7 car les architectures sont trop différentes. Pour l’instant, il semble que le choix se porte sur le module « Migrate » qui aura en charge d’aspirer les données des anciens sites. Mais ce module n’est pas magique et demande un certain travail de configuration / développement. C’est un choix stratégique qui, même s’il pénalise un peu les usager de Drupal, pourrait permettre de convertir plus facilement des sites non Drupal (WordPress, Typo3, phpBB) et d’attirer encore plus de monde vers Drupal.

Drupal, histoire et part de marchés

Quelques dates clés :

  • 1999 : Dries Buytaert commence à travailler sur ce qui deviendra Drupal.
  • 2001 : C’est en janvier 2001 que le site Drupal.org est mis en ligne et que le code de Drupal est mis à disposition.
  • 2005 : avec la version 4.5, Drupal commence à faire effet boule de neige et à attirer de plus en plus de monde dans sa communauté (multiplication des conférences et sprints de code).
  • 2008 : Drupal commence à s’imposer en entreprise avec sa version 6 grâce la réputation de son code « developer friendly » et grâce à ses awards en tant que meilleur CMS.
  • 2011 : Drupal 7, sorti en 2011 signe la consécration en tant que leader des CMS d’entreprise Open Source.

Actuellement Drupal, WordPress et Joomla sont les 3 leaders pour la conception des sites web mais ne s’adressent pas au même  segments de marchés :

  • WordPress détient la plus grosse part de marché des CMS avec presque 60% (soit 20% des sites web en général). Mais il s’adresse principalement aux blogueurs.
  • Joomla, qui est orienté petites communautés / associations détient 9% des parts de marchés des CMS et pèse 3.2% des sites web.
  • Drupal, leader en entreprise représente 5.6% des part de marchés des CMS pour 1.9% des sites web.

Mais alors que Joomla est en perte de vitesse, la croissance annuelle de Drupal est 2X plus rapide que celle de WordPress, grâce au charisme de son leader et au dynamisme de sa communauté, entre autre.

Drupal est utilisé par des sites prestigieux : Twitter, Maison Blanche, NASA, MTV, portail du gouvernement, France culture, Rue89, le Figaro, etc…

Au sein de Drupal lui même plus de 50 % des sites sont en version 7, le reste étant du Drupal 6 (43.5%), Drupal 5 étant marginal (3.5%).