Comment effectuer une intégration Drupal avec d'autres systèmes d'entreprise ?
L'intégration efficace des différents systèmes dans une entreprise aujourd'hui est un facteur élémentaire de succès. Dans un monde de technologies dynamiques et d'outils IT, Drupal se distingue car il s'agit d'un logiciel open source en constante évolution, soutenu par une large communauté. Avec sa structure flexible de modules écrits en PHP et la possibilité d'utiliser des outils comme Composer, Drupal devient une solution idéale pour intégrer divers programmes dans une organisation.
Pourquoi Drupal fonctionne-t-il bien pour l'intégration ?
En faveur de Drupal, on trouve sa flexibilité et la riche base de données de modules disponibles sur Drupal.org, qui est en constante croissance et inclut souvent des solutions prêtes à l'emploi pour l'intégration.
Il est également à noter que Drupal dispose de son API, ce qui facilite grandement la création de modules d'intégration personnalisés pour Drupal. Ce système populaire est basé sur Symfony, ce qui permet d'écrire de nouvelles intégrations encore plus rapidement et facilement, grâce à l'accès à des solutions avancées et prêtes à l'emploi. Vous n'avez pas besoin de tout recommencer à zéro, ce qui permet de gagner du temps et des ressources.
Dans notre article de blog, nous découvrirons comment exploiter le potentiel de Drupal pour l'intégrer efficacement avec d'autres systèmes de votre organisation, en profitant des puissants outils et options instantanées disponibles dans ce puissant logiciel open source.
Comment est construite l'architecture de Drupal ?
L'architecture joue un rôle crucial dans le contexte de l'intégration de Drupal avec d'autres systèmes. Cela est particulièrement vrai dans un environnement commercial dynamique, où les systèmes d'une entreprise sont souvent soumis à des modifications et doivent être facilement extensibles et prêts pour le changement.
Au fur et à mesure que les technologies et les exigences commerciales évoluent, le design flexible de Drupal permet une mise en œuvre rapide des changements et l'ajout de nouvelles fonctionnalités et intégrations. Cela est essentiel pour maintenir la compétitivité et l'efficacité opérationnelle dans l'entreprise.
Langage PHP
Drupal est écrit en PHP – un langage bien connu utilisé dans le monde entier par les développeurs web. Comment sa popularité affecte-t-elle les intégrations de Drupal avec d'autres systèmes ?
Le langage PHP est largement utilisé dans le développement d'applications web, ce qui entraîne des ensembles d'outils uniques pour les programmeurs connus sous le nom de SDK (Software Development Kits). Des exemples incluent le SDK pour les services Google ou le SDK pour l'intégration eBay.
Des bibliothèques prêtes à l'emploi, de nombreux tutoriels, et de la documentation sur la connexion système avec PHP sont également bénéfiques. Ainsi, le processus d'intégration de Drupal avec d'autres systèmes devient beaucoup plus accessible et efficace.
Composants Symfony
Drupal et Symfony vous permettent d'installer des bibliothèques prêtes à l'emploi en utilisant l'outil Composer, ce qui simplifie davantage le processus d'intégration avec des programmes externes. Ces bibliothèques sont souvent fournies par les systèmes que vous souhaitez intégrer, ce qui signifie que les entreprises peuvent utiliser des solutions officielles ou non officielles des fabricants.
Par conséquent, le processus d'intégration devient encore plus fluide, et les bibliothèques prêtes à l'emploi facilitent la création de connexions et l'échange de données entre différentes plateformes. Cela, à son tour, accélère la mise en œuvre de l'intégration.
Un exemple est l'installation de services Google tels que Google Drive ou YouTube :
{
"require": {
"google/apiclient": "^2.15.0"
},
"scripts": {
"pre-autoload-dump": "google-autoload-dump::cleanup".
},
"extra": {
"google/apiclient-services": [
"Drive,
"YouTube"
]
}
}Il convient également de mentionner le SDK fourni par Amazon :
composer require aws/aws-sdk-php
Système de template Twig
Drupal utilise le système de template Twig pour afficher le contenu sur les sites web. Bien qu'il puisse sembler non lié à l'intégration, il est essentiel pour la flexibilité de Drupal dans ce contexte. Avec Twig, un traitement avancé du contenu de sortie est possible, facilitant la communication entre différentes applications.
De plus, le système de template Twig fonctionne avec le système de bibliothèque dans Drupal. Il permet l'utilisation de bibliothèques JavaScript externes, ce qui étend les possibilités de création d'interfaces utilisateur et leur personnalisation pour un projet donné. De cette façon, Drupal devient un outil d'intégration plus flexible, nous permettant de créer des solutions web avancées.
Par exemple, nous pouvons créer des services personnalisés pour formater et filtrer le contenu affiché. Voici un exemple de transformation d'adresses www.xxxx.xxx en liens cliquables "à la volée" :
service.yml
my_module_twig_extension.twig.InlinerTwigExtension:
class: drupal_module_twig_extension\TwigExtension\TwigExtension
Tags: { name: twig.extension }Code de la classe:
public function getFilters(): array {
return [
new TwigFilter('replaceUrls', [$this, 'replaceUrls']),
];
}
/**
* Remplacer un lien URL par un lien HTML dans les textes.
*/
public function replaceUrls($text): array|string|null {
if (empty($text)) {
return $text;
}
$pattern = '/(http:\/\S+|https:\S+|www.\S+)/i';
$replacement = '$1';
$text = preg_replace($pattern, $replacement, $text);
$pattern = '/(.*?)/i';
$replacement = '$2';
return preg_replace($pattern, $replacement, $text);
}Et dans Twig, nous ajoutons notre filtre personnalisé :
{{text|replaceUrls}}Comment effectuer l'intégration de Drupal avec d'autres systèmes ?
Nous vous avons déjà rappelé les éléments de base de l'architecture de Drupal qui peuvent affecter la connexion du système avec des outils externes. Ci-dessous, nous présentons des approches spécifiques à l'intégration.
Intégration utilisant l'API Rest de Drupal
L'intégration avec l'API Rest de Drupal est un processus relativement simple et efficace. Pour pouvoir l'implémenter, nous devons activer le module Rest dans le panneau d'administration de Drupal, configurer les autorisations d'accès appropriées et créer des points de terminaison API.
Nous pouvons également utiliser l'extension REST UI, qui nous permet d'ajouter certaines actions depuis l'interface utilisateur.
Il est également important de mettre en œuvre des mécanismes d'autorisation et d'authentification pour garantir que l'accès à l'API est sécurisé.
Drupal et Symfony permettent la création personnalisée de points de terminaison REST. Les développeurs peuvent utiliser des outils tels que Guzzle et d'autres bibliothèques pour créer des points de terminaison API personnalisés qui répondent aux besoins exacts du projet. Cela signifie que la structure et le comportement de l'API peuvent être adaptés à des exigences commerciales spécifiques. En conséquence, nous réussissons à construire des solutions d'intégration personnalisées et à obtenir un échange de données accessible entre Drupal ou Symfony et d'autres applications et plateformes.
Avant de mettre en œuvre une intégration, il est conseillé de tester soigneusement l'API et de créer une documentation pour faciliter l'utilisation des ressources et des opérations fournies par l'API aux autres développeurs. De cette façon, Drupal peut être efficacement intégré avec d'autres systèmes, permettant aux données et aux processus de circuler librement entre différentes applications et outils.
Création d'un plugin pour Rest
Nous devons créer une classe avec l'annotation @RestResource ainsi que url_paths et étendre la classe RestResource. Exemple :
<?php
Namespace Drupal_your_module_Plugin_Resource;
use Drupal;
use DrupalResourceResponse;
use SymfonyComponentDependencyInjectionContainerInterface;
use SymfonyComponentHttpKernelExceptionAccessDeniedHttpException;
/**
* Fournit une ressource pour obtenir les modes de vue par entité et bundle.
*
* @RestResource(
* id = "my_custom_resource",
* label = @Translation("My Custom Resource"),
* uri_paths = {
* "canonical" = "/my-custom-endpoint".
* }
* )
*/
class MyCustomResource extends ResourceBase {
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static(
$configuration,
$plugin_id,
$plugin_definition,
$container->get('entity.manager')
);
}
/**
* Réponds aux requêtes GET.
*
* @return @DrupalResourceResponse.
* L'objet de réponse HTTP.
*
* @throws @SymfonyComponentHttpKernelException.
* Lève l'exception attendue.
*/
public function get() {
// Votre logique personnalisée ici pour gérer les requêtes GET.
// Par exemple, vous pouvez récupérer des données et les renvoyer sous forme de réponse JSON.
$data = ['message' => 'Ceci est une ressource REST personnalisée.'];
return new ResourceResponse($data);
}
/**
* Réponds aux requêtes POST.
*
* @param mixed $data
* Les données reçues dans la requête POST.
*
* @return @DrupalResourceResponse.
* L'objet de réponse HTTP.
*
* @throws @SymfonyComponentHttpKernelException.
* Lève l'exception attendue.
*/
public function post($data) {
// Votre logique personnalisée ici pour gérer les requêtes POST.
// Par exemple, vous pouvez créer une nouvelle ressource en fonction des données reçues.
// Retourner une réponse indiquant le succès ou l'échec.
return new ResourceResponse(['message' => 'Requête POST traitée.']);
}
}Une autre approche consiste à créer des routes et des contrôleurs pour recevoir nos requêtes :
my_module.resource_list:
path: '/api/resources'
defaults:
_controller: '_controller::getList'.
_title: 'Obtenir la liste des ressources'.
methods: [GET].
requirements:
_permission: 'access content'
formats: ['json']
my_module.resource_get:
path: '/api/resources/{id}'
defaults:
_controller: '_controller::getSingle'.
_title: 'Obtenir une seule ressource'
methods: [GET].
requirements:
_permission: 'access content'
options:
parameters:
id:
type: 'integer'
formats: ['json']
my_module.resource_create:
path: '/api/resources'
defaults:
_controller: '_drupal_module_Controller_ResourceController::create'.
_title: 'Créer une nouvelle ressource'
methods: [POST].
requirements:
_permission: 'create new resource'
options:
parameters:
date:
type: 'entity:my_resource'
formats: ['json']De plus, nous montrons comment télécharger des données d'exemple dans notre module personnalisé à partir de systèmes externes, tels que YouTube, en utilisant GuzzleHttpClient:
<?php
Namespace Drupal_module_Controller;
use DrupalCoreControllerBase;
use SymfonyComponentHttpFoundationJsonResponse;
use GuzzleHttpClient;
class GoogleApiIntegrationController extends ControllerBase {
public function getContent() {
// Configurer le client Guzzle
$client = new Client([
'base_uri' => 'https://www.googleapis.com/youtube/v3/', // URL de base de l'API Google
]);
// Paramètres de requête, y compris la clé API
$params = [
'query' => [
'part' => 'snippet',
'q' => 'cats', // Exemple de requête - recherche de vidéos de chat
'key' => 'YOUR_API_KEY', // Remplacer 'YOUR_API_KEY' par votre propre clé API Google
],
];
// Effectuer une requête GET
$response = $client->get('search', $params);
// Décoder le JSON de la réponse
$data = json_decode($response->getBody());
// Traiter les données de la réponse
$results = [];
foreach ($data->items as $item) {
// Vous pouvez traiter les données vidéo ici, comme afficher les titres et descriptions
$results[] = [
'title' => $item->snippet->title,
'description' => $item->snippet->description,
];
}
// Retourner les résultats sous forme de réponse JSON
return new JsonResponse($results);
}
}Intégration de Drupal via des modules
Connecter Drupal avec d'autres systèmes via des modules est une approche populaire pour étendre la fonctionnalité d'un site web, surtout s'il s'agit de systèmes tiers qui s'intègrent à notre site web.
Exemples de modules populaires :
- RESTful Web Services : le module décrit ci-dessus nous permet de créer des ressources REST et de traiter des requêtes HTTP, ce qui fonctionne bien pour la communication avec d'autres applications et services.
- Feeds : le module Feeds nous permet d'importer et d'exporter des données à partir de différentes sources, ce qui est utile pour synchroniser le contenu avec des systèmes externes. Par exemple, avec le module Feeds, nous pouvons définir la source de données et le mappage de champs entre Drupal et un autre système.
- Créer des vues : le module Views nous permet de créer des vues personnalisées qui utilisent des données d'autres systèmes et de les afficher sur notre site Drupal. Les vues peuvent également être utilisées pour présenter des données provenant d'autres systèmes. Particulièrement utile dans les intégrations est également l'option d'exposer des données au format XML, CSV ou d'autres formats, que les systèmes externes peuvent facilement consommer. Nous pouvons utiliser le module d'exportation des données Views pour cela.
L'intégration de Drupal par cette méthode est une solution pratique pour divers types de projets. Il existe des modules dédiés pour des systèmes spécifiques qui sont prêts à l'emploi ou accélèrent considérablement l'intégration. Voici quelques exemples :
- Jira – un outil de gestion de projet,
- PayPal – un système de paiement en ligne,
- HubSpot – une plateforme CRM,
- MailChimp – une plateforme d'automatisation du marketing et de marketing par courriel.
Plus de ces composants peuvent être trouvés sur Drupal.org dans la catégorie Third-party Integration
.
Intégration de Drupal avec Salesforce
Salesforce est l'une des plus grandes et des plus connues entreprises de logiciels de gestion de la relation client. Elle propose diverses solutions et outils de CRM (Customer Relationship Management) pour automatiser les processus commerciaux, le marketing, le service client, et l'analyse de données.
En utilisant son exemple, nous allons montrer à quel point il est facile d'intégrer ce type de système avec Drupal.
Tout d'abord, nous pouvons utiliser un module disponible sur Drupal.org – Salesforce.
Le composant principal contient un ensemble de modules qui supportent l'intégration avec Salesforce en synchronisant diverses Entités (e.g., utilisateurs, nœuds, fichiers) avec des objets Salesforce (e.g., contacts, pistes). Il supporte le chargement de données depuis Drupal vers Salesforce, ainsi que le téléchargement ou l'importation de données de Salesforce vers Drupal. Les modifications peuvent être effectuées en temps réel ou de manière asynchrone par lots lors de l'exécution de cron.
Si, pour une raison quelconque, nous avons besoin de solutions plus personnalisées, nous pouvons étendre cela avec notre propre module. L'API Salesforce a des classes et un ensemble de hooks pour l'extension, tels que :
/**
* Implémente un EventSubscriber sur SalesforceEvents::PUSH_PARAMS.
*/
function hook_salesforce_push_params_alter() {
}
/**
* Implémente un EventSubscriber sur SalesforceEvents::PUSH_SUCCESS.
*/
function hook_salesforce_push_success() {
}
/**
* Implémente un EventSubscriber sur SalesforceEvents::PUSH_FAIL.
*/
function hook_salesforce_push_fail() {
}Nous pouvons également utiliser un SDK dédié pour PHP, téléchargé avec Composer, qui nous permet de recevoir et d'envoyer facilement des données vers Salesforce.
Intégrations Drupal via Zapier
L'intégration système via Zapier est le processus de connexion de différentes applications, outils et systèmes pour automatiser des tâches et transférer des données entre eux en utilisant la plateforme mentionnée. Zapier permet la création de règles ou "zaps" qui déterminent ce qui se passera lorsqu'un certain événement se produit dans un système et quelles actions seront entreprises dans un autre.
Pourquoi l'intégration avec Zapier est-elle utile et quels avantages apporte-t-elle ?
- Connexion simple et rapide : L'intégration avec des systèmes utilisant Zapier est facile à configurer et ne nécessite pas de connaissances techniques avancées. Nous pouvons créer nos propres zaps, les personnalisant pour répondre à nos besoins en quelques minutes.
- Automatisation des tâches : Zapier permet l'automatisation de nombreuses tâches et processus, économisant du temps et évitant les erreurs humaines. Cela nous permet de nous concentrer sur des aspects plus stratégiques de l'entreprise.
- Fonctionnalité étendue : Avec le support de centaines d'applications et outils, Zapier nous permet de créer des solutions plus avancées et intégrées. Nous pouvons synchroniser des données, générer des notifications, créer des rapports, et plus, en combinant différents systèmes en un environnement de travail cohérent.
Un exemple d'intégration simple de Drupal avec Excel via Zapier :
Source : Zapier
Intégrations Drupal - résumé
Drupal est un système hautement flexible en termes d'extensibilité, offrant une intégration illimitée avec d'autres solutions et outils. En tant que logiciel open source, il dispose d'une large gamme de modules d'intégration disponibles sur Drupal.org, qui nous permettent de connecter un site web à diverses applications, y compris CRM, e-commerce, réseaux sociaux, etc.
Avec son propre API et les composants Symfony, Drupal nous permet de créer des intégrations personnalisées, nous donnant un contrôle complet sur le processus de communication entre les systèmes. La protection des données est une priorité, et Drupal maintient les normes de sécurité les plus élevées lors de l'intégration. Si vous avez besoin d'aide avec cet outil pour créer des sites web personnalisés et intégrés, obtenez de l'assistance auprès de une agence Drupal expérimentée.
