Wie führt man eine Drupal-Integration mit anderen Enterprise-Systemen durch?
Die effektive Integration verschiedener Systeme in einem Unternehmen ist heute ein grundlegender Erfolgsfaktor. In einer Welt dynamischer Technologien und IT-Werkzeuge sticht Drupal hervor, da es sich um eine ständig weiterentwickelte Open-Source-Software mit Unterstützung einer großen Gemeinschaft handelt. Mit seiner flexiblen Struktur von in PHP geschriebenen Modulen und der Möglichkeit, Werkzeuge wie Composer zu nutzen, wird Drupal zu einer idealen Lösung für die Integration verschiedener Programme in einer Organisation.
Warum funktioniert Drupal gut für die Integration?
Für Drupal spricht seine Flexibilität und die umfangreiche Datenbank von Modulen, die auf Drupal.org verfügbar sind und ständig wachsen, oft mit einsatzbereiten Lösungen für die Integration.
Es ist auch erwähnenswert, dass Drupal über eine eigene API verfügt, was die Erstellung benutzerdefinierter Drupal-Integrationsmodule erheblich erleichtert. Dieses beliebte System basiert auf Symfony, das das Schreiben neuer Integrationen schneller und einfacher macht, dank des Zugriffs auf fortschrittliche, fertige Lösungen. Sie müssen nicht alles von Grund auf neu erstellen, was Zeit und Ressourcen spart.
In unserem Blogbeitrag werden wir entdecken, wie Sie das Potenzial von Drupal nutzen können, um es effektiv mit anderen Systemen in Ihrer Organisation zu integrieren, indem Sie die leistungsstarken Tools und sofort verfügbaren Optionen dieser mächtigen Open-Source-Software nutzen.
Wie ist die Drupal-Architektur aufgebaut?
Die Architektur spielt eine entscheidende Rolle im Kontext der Drupal-Integration mit anderen Systemen. Dies gilt insbesondere in einem dynamischen Geschäftsumfeld, in dem die Systeme eines Unternehmens häufig geändert werden müssen und leicht erweiterbar und bereit für Änderungen sein müssen.
Da sich Technologien und Geschäftsanforderungen weiterentwickeln, ermöglicht das flexible Design von Drupal eine schnelle Implementierung von Änderungen und die Hinzufügung neuer Funktionen und Integrationen. Dies ist entscheidend, um Wettbewerbsfähigkeit und operative Effizienz im Unternehmen zu erhalten.
PHP-Sprache
Drupal ist in PHP geschrieben – einer weltweit von Webentwicklern verwendeten Sprache. Wie beeinflusst seine Popularität die Drupal-Integrationen mit anderen Systemen?
Die PHP-Sprache wird häufig zur Entwicklung von Webanwendungen verwendet, was zu einzigartigen Werkzeugkästen für Programmierer, bekannt als SDKs (Software Development Kits), führt. Beispiele hierfür sind das SDK für Google-Dienste oder das SDK für die eBay-Integration.
Fertige Bibliotheken, zahlreiche Tutorials und Dokumentationen zur Systemverbindung in PHP sind ebenfalls von Vorteil. Dadurch wird der Prozess der Drupal-Integration mit anderen Systemen erheblich zugänglicher und effizienter.
Symfony-Komponenten
Drupal und Symfony ermöglichen die Installation vorgefertigter Bibliotheken mithilfe des Composer-Tools, was den Integrationsprozess mit externen Programmen weiter vereinfacht. Diese Bibliotheken werden häufig von den Systemen bereitgestellt, mit denen Sie sich integrieren möchten, was bedeutet, dass Unternehmen offizielle oder inoffizielle Lösungen von Herstellern nutzen können.
Infolgedessen wird der Integrationsprozess noch reibungsloser, und fertige Bibliotheken erleichtern die Erstellung von Verbindungen und den Austausch von Daten zwischen verschiedenen Plattformen. Dies wiederum beschleunigt die Implementierung der Integration.
Ein Beispiel ist die Installation von Google-Diensten wie Google Drive oder YouTube:
{
"require": {
"google/apiclient": "^2.15.0"
},
"scripts": {
"pre-autoload-dump": "google-autoload-dump::cleanup".
},
"extra": {
"google/apiclient-services": [
"Drive,
"YouTube"
]
}
}Erwähnenswert ist auch das von Amazon bereitgestellte SDK:
composer require aws/aws-sdk-php
Twig-Templatesystem
Drupal verwendet das Twig-Templatesystem, um Inhalte auf Websites zu rendern. Während es zunächst nicht mit der Integration zusammenhängt, ist es im Kontext von Drupals Flexibilität entscheidend. Mit Twig ist eine fortschrittliche Ausgabeverarbeitung von Inhalten möglich, die die Kommunikation zwischen verschiedenen Anwendungen erleichtert.
Darüber hinaus arbeitet das Twig-Templatesystem mit dem Bibliothekensystem in Drupal. Es ermöglicht externe JavaScript-Bibliotheken, was die Möglichkeiten zur Erstellung von Benutzeroberflächen und deren Anpassung an ein bestimmtes Projekt erweitert. Auf diese Weise wird Drupal zu einem flexibleren Integrationstool, mit dem wir fortschrittliche Weblösungen schaffen können.
Beispielsweise können wir benutzerdefinierte Dienste zur Formatierung und Filterung der angezeigten Inhalte erstellen. Hier ist ein Beispiel, wie man www.xxxx.xxx-Adressen „on the fly“ in anklickbare Links verwandelt:
service.yml
my_module_twig_extension.twig.InlinerTwigExtension:
class: drupal_module_twig_extension\TwigExtension\TwigExtension
Tags: { name: twig.extension }Klassen-Code:
public function getFilters(): array {
return [
new TwigFilter('replaceUrls', [$this, 'replaceUrls']),
];
}
/**
* Ersetzt URL-Link durch HTML-Link in Texten.
*/
public function replaceUrls($text): array|string|null {
if (empty($text)) {
return $text;
}
$pattern = '/(http:\/\S+|https:\S+|www.\S+)/i';
$replacement = '<a href="$1" target="_blank">$1</a>';
$text = preg_replace($pattern, $replacement, $text);
$pattern = '/<a href="www.(.*?)">(.*?)</a>/i';
$replacement = '<a href="http://www.$1">$2</a>';
return preg_replace($pattern, $replacement, $text);
}Und in Twig fügen wir unseren benutzerdefinierten Filter hinzu:
{{text|replaceUrls}}Wie wird die Drupal-Integration mit anderen Systemen durchgeführt?
Wir haben bereits die grundlegenden Elemente der Drupal-Architektur hervorgehoben, die die Verbindung des Systems mit externen Tools beeinflussen können. Nachfolgend stellen wir spezifische Ansätze zur Integration vor.
Integration mit Drupal Rest API
Die Integration mit der Drupal Rest API ist ein relativ einfacher und effektiver Prozess. Um sie implementieren zu können, müssen wir das Rest-Modul im Drupal-Admin-Panel aktivieren, die entsprechenden Zugriffsberechtigungen konfigurieren und API-Endpunkte erstellen.
Wir können auch das REST UI-Add-on verwenden, das uns ermöglicht, einige Aktionen aus der Benutzeroberfläche hinzuzufügen.
Es ist auch wichtig, Autorisierungs- und Authentifizierungsmechanismen zu implementieren, um sicherzustellen, dass der API-Zugriff sicher ist.
Drupal und Symfony ermöglichen die benutzerdefinierte Erstellung von REST-Endpunkten. Entwickler können Tools wie Guzzle und andere Bibliotheken verwenden, um benutzerdefinierte API-Endpunkte zu erstellen, die den genauen Anforderungen des Projekts entsprechen. Dies bedeutet, dass die Struktur und das Verhalten der API an spezifische Geschäftsanforderungen angepasst werden können. Infolgedessen können wir personalisierte Integrationslösungen erstellen und einen zugänglichen Datenaustausch zwischen Drupal oder Symfony und anderen Anwendungen und Plattformen erreichen.
Vor der Implementierung einer Integration ist es ratsam, die API gründlich zu testen und eine Dokumentation zu erstellen, die die Nutzung der von der API bereitgestellten Ressourcen und Operationen durch andere Entwickler erleichtert. Auf diese Weise kann Drupal effektiv mit anderen Systemen integriert werden, sodass Daten und Prozesse frei zwischen verschiedenen Anwendungen und Tools fließen können.
Erstellung eines Plugins für Rest
Wir müssen eine Klasse mit der Annotation @RestResource zusammen mit url_paths erstellen und die Klasse RestResource erweitern. Beispiel:
<?php
Namespace Drupal_your_module_plugin_resource;
use Drupal;
use DrupalResourceResponse;
use SymfonyComponentDependencyInjectionContainerInterface;
use SymfonyComponentHttpKernelExceptionAccessDeniedHttpException;
/**
* Bietet eine Ressource zum Abrufen von Anzeigemodi nach Entität und 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')
);
}
/**
* Reagiert auf GET-Anfragen.
*
* @return @DrupalResourceResponse.
* Das HTTP-Antwortobjekt.
*
* @throws @SymfonyComponentHttpKernelException.
* Wirft erwartete Ausnahme.
*/
public function get() {
// Ihre benutzerdefinierte Logik hier zur Bearbeitung von GET-Anfragen.
// Zum Beispiel können Sie Daten abrufen und als JSON-Antwort zurückgeben.
$data = ['message' => 'Dies ist eine benutzerdefinierte REST-Ressource.'];
return new ResourceResponse($data);
}
/**
* Reagiert auf POST-Anfragen.
*
* @param mixed $data
* Die in der POST-Anfrage empfangenen Daten.
*
* @return @DrupalResourceResponse.
* Das HTTP-Antwortobjekt.
*
* @throws @SymfonyComponentHttpKernelException.
* Wirft erwartete Ausnahme.
*/
public function post($data) {
// Ihre benutzerdefinierte Logik hier zur Bearbeitung von POST-Anfragen.
// Zum Beispiel können Sie basierend auf den empfangenen Daten eine neue Ressource erstellen.
// Geben Sie eine Antwort zurück, die den Erfolg oder Misserfolg anzeigt.
return new ResourceResponse(['message' => 'POST-Anfrage bearbeitet.']);
}
}Ein weiterer Ansatz besteht darin, Routen und Controller zu erstellen, um unsere Anfragen zu empfangen:
my_module.resource_list:
path: '/api/resources'
defaults:
_controller: '_controller::getList'.
_title: 'Liste der Ressourcen abrufen'.
methods: [GET].
requirements:
_permission: 'Zugriff auf Inhalte'
my_module.resource_get:
path: '/api/resources/{id}'
defaults:
_controller: '_controller::getSingle'.
_title: 'Eine einzelne Ressource abrufen'
methods: [GET].
requirements:
_permission: 'Zugriff auf Inhalte'
options:
parameters:
id:
type: 'integer'
my_module.resource_create:
path: '/api/resources'
defaults:
_controller: '_drupal_module_Controller_ResourceController::create'.
_title: 'Erstellen Sie eine neue Ressource'
methods: [POST].
requirements:
_permission: 'neue Ressource erstellen'
options:
parameters:
date:
type: 'entity:my_resource'Darüber hinaus zeigen wir, wie Daten in unserem benutzerdefinierten Modul von externen Systemen wie YouTube, unter Verwendung von GuzzleHttpClient, heruntergeladen werden können:
<?php
Namespace Drupal_module_Controller;
use DrupalCoreControllerBase;
use SymfonyComponentHttpFoundationJsonResponse;
use GuzzleHttpClient;
class GoogleApiIntegrationController extends ControllerBase {
public function getContent() {
// Konfiguriert den Guzzle-Client
$client = new Client([
'base_uri' => 'https://www.googleapis.com/youtube/v3/', // Google API-Basis-URL
]);
// Abfrageparameter, einschließlich des API-Schlüssels
$params = [
'query' => [
'part' => 'snippet',
'q' => 'cats', // Beispielabfrage - Suche nach Katzenvideos
'key' => 'YOUR_API_KEY', // Ersetzen Sie 'YOUR_API_KEY' durch Ihren eigenen Google API-Schlüssel
],
];
// Führen Sie eine GET-Anfrage durch
$response = $client->get('search', $params);
// Dekodieren Sie die Antwort als JSON
$data = json_decode($response->getBody());
// Verarbeiten Sie Daten aus der Antwort
$results = [];
foreach ($data->items as $item) {
// Sie können hier Videodaten verarbeiten, z.B. Titel und Beschreibungen anzeigen
$results[] = [
'title' => $item->snippet->title,
'description' => $item->snippet->description,
];
}
// Geben Sie die Ergebnisse als JSON-Antwort zurück
return new JsonResponse($results);
}
}Drupal-Integration durch Module
Das Verbinden von Drupal mit anderen Systemen über Module ist ein beliebter Ansatz, um die Funktionalität der Website zu erweitern. Besonders, wenn es sich um Drittsysteme handelt, die mit unserer Webseite integriert werden.
Beispiele für beliebte Module umfassen:
- RESTful Web Services: Das oben beschriebene Modul ermöglicht uns die Erstellung von REST-Ressourcen und die Bearbeitung von HTTP-Anfragen, die sich gut zur Kommunikation mit anderen Anwendungen und Diensten eignen.
- Feeds: Das Feeds-Modul ermöglicht uns den Import und Export von Daten aus verschiedenen Quellen, was hilfreich ist, um Inhalte mit externen Systemen zu synchronisieren. Beispielsweise können wir mit dem Feeds-Modul die Datenquelle und das Feldmapping zwischen Drupal und einem anderen System definieren.
- Views erstellen: Das Views-Modul ermöglicht es uns, benutzerdefinierte Ansichten zu erstellen, die Daten aus anderen Systemen verwenden und auf unserer Drupal-Website anzeigen. Views kann auch verwendet werden, um Daten aus anderen Systemen zu präsentieren. Besonders nützlich bei Integrationen ist auch die Option, Daten im XML-, CSV- oder anderen Formaten freizugeben, die externe Systeme leicht konsumieren können. Wir können das Views Data Export-Modul zu diesem Zweck verwenden.
Die Drupal-Integration auf diese Weise ist eine praktische Lösung für verschiedene Arten von Projekten. Es gibt spezielle Module für bestimmte Systeme, die einsatzbereit sind oder die Integration erheblich beschleunigen. Einige Beispiele sind:
- Jira – ein Projektmanagement-Tool,
- PayPal – ein Online-Zahlungssystem,
- HubSpot – eine CRM-Plattform,
- MailChimp – eine Marketingautomations- und E-Mail-Marketing-Plattform.
Weitere solche Komponenten finden Sie auf Drupal.org in der Third-party Integration
Kategorie.
Drupal Salesforce-Integration
Salesforce ist eines der größten und bekanntesten Unternehmen für Kundenmanagement-Software. Es bietet verschiedene CRM-Lösungen (Customer Relationship Management) und Tools zur Automatisierung von Geschäftsprozessen, Marketing, Kundenservice und Datenanalyse.
Am Beispiel von Salesforce zeigen wir, wie einfach es ist, eine solche Art von System mit Drupal zu integrieren.
Zunächst können wir ein auf Drupal.org verfügbares Modul nutzen – Salesforce.
Die Hauptkomponente enthält eine Reihe von Modulen, die die Integration mit Salesforce durch die Synchronisierung verschiedener Entitäten (z.B. Benutzer, Knoten, Dateien) mit Salesforce-Objekten (z.B. Kontakte, Leads) unterstützen. Sie unterstützt das Hochladen von Daten von Drupal nach Salesforce sowie das Herunterladen oder Importieren von Daten von Salesforce nach Drupal. Änderungen können in Echtzeit oder asynchron in Batches bei der Ausführung von Cron durchgeführt werden.
Falls wir aus irgendeinem Grund mehr benutzerdefinierte Lösungen benötigen, können wir dies mit unserem eigenen Modul erweitern. Die Salesforce-API verfügt über Klassen und eine Reihe von Hooks zur Erweiterung, wie zum Beispiel:
/**
* Implementieren Sie einen EventSubscriber auf SalesforceEvents::PUSH_PARAMS.
*/
function hook_salesforce_push_params_alter() {
}
/**
* Implementieren Sie einen EventSubscriber auf SalesforceEvents::PUSH_SUCCESS.
*/
function hook_salesforce_push_success() {
}
/**
* Implementieren Sie einen EventSubscriber auf SalesforceEvents::PUSH_FAIL.
*/
function hook_salesforce_push_fail() {
}Wir können auch ein spezielles SDK für PHP verwenden, das mit Composer heruntergeladen werden kann und uns ermöglicht, Daten einfach an Salesforce zu senden und von dort zu empfangen.
Drupal-Integrationen durch Zapier
Die Systemintegration durch Zapier ist der Prozess des Verbindens verschiedener Anwendungen, Werkzeuge und Systeme, um Aufgaben zu automatisieren und Daten zwischen ihnen über die oben genannte Plattform zu übertragen. Zapier ermöglicht die Erstellung von Regeln oder "Zaps", die bestimmen, was passiert, wenn ein bestimmtes Ereignis in einem System auftritt und welche Maßnahmen in einem anderen ergriffen werden.
Warum ist die Integration mit Zapier nützlich und welche Vorteile bringt sie mit sich?
- Einfache und schnelle Verbindung: Die Integration mit Systemen über Zapier ist einfach einzurichten und erfordert keine erweiterten technischen Kenntnisse. Wir können unsere eigenen Zaps erstellen, die in wenigen Minuten an unsere Bedürfnisse angepasst sind.
- Automatisierung von Aufgaben: Zapier ermöglicht die Automatisierung vieler Aufgaben und Prozesse, spart Zeit und vermeidet menschliche Fehler. So können wir uns auf strategischere Aspekte des Geschäfts konzentrieren.
- Erweiterte Funktionalität: Mit Unterstützung für Hunderte von Anwendungen und Tools ermöglicht Zapier uns, fortgeschrittenere und integrierte Lösungen zu schaffen. Wir können Daten synchronisieren, Benachrichtigungen generieren, Berichte erstellen und mehr, indem wir verschiedene Systeme in eine kohärente Arbeitsumgebung integrieren.
Ein Beispiel für eine einfache Drupal-Integration mit Excel über Zapier:
Quelle: Zapier
Drupal-Integrationen - Zusammenfassung
Drupal ist ein äußerst flexibles System, was die Erweiterbarkeit angeht, und bietet unbegrenzte Integrationsmöglichkeiten mit anderen Lösungen und Tools. Als Open-Source-Software verfügt es über eine breite Palette von Integrationsmodulen auf Drupal.org, die es uns ermöglichen, eine Website mit verschiedenen Anwendungen wie CRM, E-Commerce, sozialen Medien usw. zu verbinden.
Mit seiner eigenen API und Symfony-Komponenten ermöglicht Drupal es uns, benutzerdefinierte Integrationen zu erstellen, die uns die vollständige Kontrolle über den Kommunikationsprozess zwischen den Systemen geben. Der Schutz der Daten hat Priorität, und Drupal hält während der Integration höchste Sicherheitsstandards ein. Wenn Sie Hilfe bei diesem Tool zum Erstellen von personalisierten und integrierten Websites benötigen, erhalten Sie Unterstützung von einer erfahrenen Drupal-Agentur.
