Warnung!

Du solltest geübt im Umgang mit der Shell, Bash und WordPress sein und unbedingt Backups nutzen. Das Script verwendet, wenn der entsprechende Parameter gesetzt ist, den Befehl “rm -rf”, um einen Ordner komplett zu löschen. Dieser Schritt lässt sich nicht widerrufen. Außerdem wird, sofern per Parameter gefordert, eine Datenbank mit “DROP DATABASE” komplett entfernt. Wenn du das Script auf eine existierende WordPress-Installation oder Datenbank anwendest, können existierende Daten überschrieben werden!

Funktionsweise

Das Script wird über die Kommandozeile aufgerufen und nutzt die [WordPress Kommandozeilen-Benutzeroberfläche,](um WordPress zu installieren sowie samt Themes und Plugins einzurichten. Du kannst außerdem beliebig viele Beiträge anlegen. Die Inhalte für die Beiträge stammen von einem Online-Dienst für zufällige englische Texte: [metaphorpsum.com/paragraphs](Außerdem werden zufällige Textauszüge (Excerpts) sowie Schlagwörter (Tags) und sogar Bilder jedem Beitrag hinzugefügt. Beiträge werden außerdem Kategorien zugeordnet. Diese werden ebenfalls zufällig bis zu einer Tiefe von 2 Ebenen erzeugt.

Installation

Du findest den Sourcecode auf github: https://github.com/nickyreinert/AutomatedWordPressInstallation .

Nach der Installation kopierst du die Datei settings-template zu .settings, um in dieser Datei die Einstellungen für deine WordPress-Installation vorzunehmen. Du startest den Prozess mit bash start.sh oder setzt den Ausführen-Flag für bash.sh um diese direkt auszuführen:

1chmod u+x bash.sh
2./bash.sh

Zufällige Inhalte

Das Script ermöglicht das Anlegen von beliebig vielen zufälligen Beiträgen in beliebig vielen zufälligen Kategorien. Was genau dabei passiert, beschreibe ich hier kurz:

Zunächst wird eine Kategorie erzeugt. Dazu wird von der folgenden API ein zufälliges Wort abgerufen: https://random-word-api.herokuapp.com/word?swear=0&number=

Dieser Kategorie wird dann ein Beitrag wird mit einer beliebigen Anzahl von Absätzen von dieser API zugeordnet: http://metaphorpsum.com/paragraphs/ . Der Beitrag erhält einen zufälligen Titel (von dort: http://metaphorpsum.com/sentences ), einen Textauszug (gleiche API), sowie eine beliebige Anzahl zufälliger Tags (Schlagwörter), ebenfalls von random-word-api.herokuapp.com . Dann werden für diesen Beitrag Revisionen erzeugt - auch diese in beliebiger Höhe. Abschließend erhält jeder Beitrag ein zufälliges Featured Image sowie ein weiteres zufälliges Bild am Ende des Fließtextes.

Je nachdem, wieviele Beiträge und Kategorien bzw. Sub-Kategorien eingerichtet werden soll, wird dieser Prozess natürlich wiederholt.

(Bisher werden die Inhalte leider nur auf Englisch eingefügt)

Einstellungen

Alle Einstellungen befinden sich in der Datei .settings und werden im Folgenden beschrieben. Der PROJECT-Parameter kann im weiteren Verlauf als Platzhalter verwendet werden und sollte keine Leerzeichen oder Sonderzeichen enthalten:

1PROJECT=myWordPressBlog

Datenbank

Du kannst eine neue Datenbank anlegen (CREATE_DB) oder auf eine existierende Datenbank zurückgreifen.

1DB_DROP=yes|no
2CREATE_DB=yes|no
3DB_ROOT=root
4DB_ROOT_PASSWORD=secret

Willst du eine frische Datenbank anlegen, solltest du die alte Datenbank mit DB_DROP=yes löschen. Soll eine neue Datenbank angelegt werden, müssen die Zugangsdaten für einen privilegierten Nutzer angegeben werden: Mit den folgenden Parameter legst du fest, wie WordPress auf die Datenbank zugreift:

1DB_HOST=127.0.0.1
2DB_NAME="${PROJECT}"
3DB_PREFIX="wp_"
4
5ADD_DB_USER=yes|no
6DB_USER="${PROJECT}"
7DB_USER_PASSWORD=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)

Das Passwort wird im Beispiel zufällig erzeugt, willst du ein eigenes Passwort verwenden, kannst du den Parameter überschreiben, z.B:

1DB_USER_PASSWORT=secret

Der DB-Nutzer wird natürlich nur angelegt, wenn ADD_DB_USER=yes gesetzt ist. Andernfalls musst du hier die passenden Zugangsdaten angeben.

WordPress

Du kannst auf eine existierende Installation zurückgreifen, um z.B. dort Beiträge hinzuzufügen, oder WordPress komplett neu installieren. Hier kannst du z.B. auch den oben festgelegten PROJECT-Parameter nutzen:

1WP_PATH="/var/nginx/htdocs/${PROJECT}/"
2INSTALL_CORE=yes|no
3WP_DROP=yes|no

Mit WP_DROP kannst du festlegen, dass der Ordner WP_PATH komplett gelöscht wird. Vorsicht ist hier also geboten! Die folgenden Parameter betreffen deine allgemeinen WordPress-Einstellungen. Bei der URL kannst du wieder den PROJECT-Platzhalter nutzen.

1WP_TITLE='WordPress Test'
2URL="https://blog.example.org/${PROJECT}"
3WP_ADMIN_NAME=admin
4WP_ADMIN_EMAIL=mail@example.org
5WP_ADMIN_PASSWORD=secret

Willst du ein eigene Passwort vergeben, kannst du auch hier ein zufälliges Passwort erzeugen lassen:

1WP_ADMIN_PASSWORD=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)

Theme und Plugins

Mit den folgenden Parametern legst du fest, welches Theme eingerichtet und welche Plugins installiert werden sollen. Der Theme-Name ist der Slug des Themes:

1INSTALL_THEME=yes|no
2THEME="elementor"
3
4INSTALL_PLUGINS=no
5PLUGINS="elementor wordpress-seo tinymce-advanced ninja-forms shortcodes-ultimate instagram-feed ml-slider the-events-calendar amp contact-widgets coblocks woocommerce"

Du kannst mehrere Plugins angeben, wenn diese per Leerzeichen voneinander getrennt sind.

Inhalte

Der nächste Abschnitt regelt das (zufällige) Anlegen von Beiträgen, Kategorien usw. Natürlich musst du keine Inhalte anlegen. Ist RANDOMIZE_EVERY_ITEM auf yes gesetzt, wird jeder Beitrag wie oben zufällig erzeugt. Da das eine Menge HTTP-Requests erfordert, kannst du den Parameter auch auf no setzen. In dem Fall wird jede Zufalls-API genau einmal abgerufen. Der ganze Prozess wird dadurch maßgeblich beschleunigt.

1ADD_CONTENT=yes|no
2META_INPUT=""
3RANDOMIZE_EVERY_ITEM=yes|no

Manche Themes, wie z.B. Elementor, fügen den Inhalten, also Beiträgen, bestimmte Meta-Informationen hinzu. Beim automatisierten Anlegen von Beiträgen passiert das allerdings nicht automatisch. Du kannst das hier also entsprechend einrichten. Der Wert wird als JSON übergeben. Achte auf das einfache Anführungszeichen.

1META_INPUT='{"_elementor_edit_mode":"<![CDATA[builder]]>","_elementor_template_type":"<![CDATA[kit]]>","_elementor_version":"<![CDATA[2.9.13]]>"}'

Die folgenden Paremeter legen fest, wieviele Inhalte du erzeugen möchtest:

1COUNT_CATEGORIES_LEVEL1=10
2COUNT_CATEGORIES_LEVEL2=5
3
4COUNT_POSTS=100
5COUNT_PARAGRAPHS=20
6COUNT_POST_REVISIONS=5
7COUNT_TAGS=20

Im Beispiel werden 10 Haupt-Kategorien mit jeweils 5 Unter-Kategorien angelegt. Jede Kategorie wird mit 100 Posts befüllt und jeder Post erhält 20 Tags und 5 Revisionen. Das ergibt also 10 * 5 * 100 * 5 Beiträge = 25.000 Beiträge! In diesem Fall macht es Sinn RANDOMIZE_EVERY_ITEM auf no zu setzen, da du sonst mehre tausende Anfragen an die Zufalls-APIs generieren würdest. COUNT_PARAGRAPHS legt die Länge jedes Beitrags in Absätzen fest.

Standard-Parameter

Die folgenden Parameter musst du in der Regel nicht anpassen. WP_CLI legt den Pfad zur WordPress Kommandozeilen Oberfläche fest. Wird die Datei nicht gefunden, muss WP CLI installiert werden. Dazu dient der Parameter WP_CLI_SOURCE.

1WP_CLI_EXEC=~/wp-cli.phar
2WP_CLI_SOURCE=https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar

Im folgenden werden die Quellen für die APIs festgelegt. Hier solltest du nichts ändern, da das Script für die Zusammenarbeit mit diesen Quellen eingerichtet ist. Einzig beim Parameter RANDOM_IMAGE_API_URI kannst du bei Bedarf in der URL die Auflösung der abgefragten Bilder festlegen.

1RANDOM_WORD_API_URL='https://random-word-api.herokuapp.com/word?swear=0&number='
2RANDOM_SENTENCE_API_URL='http://metaphorpsum.com/sentences/'
3RANDOM_TEXT_API_URL='http://metaphorpsum.com/paragraphs/'
4RANDOM_IMAGE_API_URI='https://picsum.photos/200/300.jpg'

Was ist eine Word Cloud?

Eine Word Cloud, auch Schlagwortwolke, Wortwolke usw., dient der besseren Visualisierung von Texten. Um eine Word Cloud zu erstellen, werden die Vorkommen von Wörtern eines Textes gezählt. Die Wörter mit der größten Häufigkeit werden groß dargestellt, Wörter mit geringerer Häufigkeit weniger groß. Und das ganze wird dann in einer Wolkenform dargestellt, mit den größten Wörtern in der Mitte.

So ist es möglich auf einen Blick zu erkennen, welche Wörter in einem Text am häufigsten vorkommen. Das ist nicht nur bei der Analyse von Texten sondern auch von Webseiten nützlich. So kannst du z.B. bei WordPress eine Word Cloud aus Tags erstellen (Tag Cloud), anhand der man sehen kann, welche Tags auf einer Seite am meisten verwendet wurden.

Die folgende Word Cloud zeigt auf einen Artikel, in dem ich einen Algorithmus beschreibe, um in JavaScript ein Labyrinth zu erstellen :

[wp-word-cloud source-type=“id” id=“demo1” size-factor=50 min-alpha=0.5 count-words=1]3334[/wp-word-cloud]

Was kann dieses Plugin?

WP Word Cloud stellt einen Shortcode zur Verfügung, mit dem du beliebig viele Word Clouds auf deinen Seiten einfügen kannst. Du kannst verschiedene Quellen nutzen, um dort die Wörter zu zählen und in einer Word Cloud darstellen zu lassen.

• inline - du gibst den Text direkt im Shortcode im Beitrag an
• url - ein Verweis auf eine Internetadresse
• id - der Verweis auf eine Seite / einen Beitrag
• sql - eine SQL-Abfrage um Text aus der Datenbank zu lesen
• custom-field - Text aus einem custom field des Beitrages / der Seite
• Text, den der Besucher der Webseite selber eingeben kann
• Text von einem Bild, das der Besucher der Website hochlädt

Das Plugin greift auf zwei sehr großartige Bibliotheken zurück: WodCloud2.js von TimDream ( github.com ). Sowie die Offline-Implementierung von Tesseract in JavaScript ( github.com ).

Installation

Über die Kommandozeile

Wenn du Zugriff auf deinen Server über SSH hast, kannst du das Plugin folgendermaßen installieren:

Wechsle in den Plugin-Ordner deiner WordPress-Installation und lege dort einen neuen Ordner an: WP-Word-Cloud, wechsle danach in diesen Ordner:

1mkdir /htdocs/wp-content/plugins/WP-Word-Cloud
2cd /htdocs/wp-content/plugins/WP-Word-Cloud

Danach kannst du das Plugin-Repository mit git klonen:

1git clone https://github.com/nickyreinert/wordCloud-for-Wordpress.git .

Wenn du git nicht benutzen möchtest oder kannst, kannst du das Plugin auch mit wget herunterladen und dann entpacken. Dann musst du den Plugin-Ordner allerdings nicht selber erstellen:

1cd /htdocs/wp-content/plugins/
2wget https://github.com/nickyreinert/wordCloud-for-Wordpress/archive/wordCloud-for-wordPress-2.zip --no-check-certificate
3unzip wordCloud-for-wordPress-2.zip -d WP-Word-Cloud

Mit einem FTP-Programm

Wenn du keinen Zugriff auf die Kommandozeile hast, kannst du das Plugin von dieser Adresse herunterladen:

https://github.com/nickyreinert/wordCloud-for-Wordpress/archive/wordCloud-for-wordPress-2.zip

Danach entpackst du das Archiv und lädst den kompletten Ordner in das Plugin-Verzeichnis deiner WordPress-Installation. Du kannst den Ordner mit dem FTP-Programm dann umbenennen:

Der Order für das Word Cloud Plugin

Abschluss der Installation

Abschließend muss das Plugin noch im Backend von WordPress aktiviert werden. Dazu suchst du im Plugin-Bereich nach dem Eintrag “WP Word Cloud” und klickst auf “aktivieren”. Fertig.

Aktiviere das Plugin in der Plugin-Übersicht von WordPress

Erste Verwendung

Das Plugin aktiviert für deine WordPress-Installation einen neuen Shortcode: [ wp-word-cloud ]. Diesen kannst du nun auf jeder Seite und in jedem Beitrag beliebig oft einfügen. Wenndu den Gutenberg-Editor verwendest, benötigst du dafür den Block “Shortcode”. Im konventionellen Editor kannst du den Shortcode einfach in deinen Text einfügen.
Eine einfache Implementierung sieht z.B. so aus:

[ wp-word-cloud source-type="url" id="meine-word-cloud" ]https://www.spiegel.de[ /wp-word-cloud ]

Es gibt drei Parameter, die du immer angeben musst:

• id, eine eindeutige Id, mit der die Word Cloud auf deiner Seite angesprochen wird, z.B. meine-word-cloud oder einfach nur test
• source-type, welcher Art die Quelle für die Word Cloud ist, also z.B. von einer url oder den tags
• sowie Inline-Text, als Verweis auf die Quelle, von wo der Inhalt für die Word Cloud kommt, also z.B. die URL https://www.spiegel.de oder die Id eines Beitrages (123)

Zusätzliche Einstellungen

Natürlich gibt es noch eine Menge weiterer Parameter, mit denen du das Erscheinungsbild der Word Cloud steuern kannst. Das Plugin setzt bei der ersten Installation für all diese Parameter Standard-Einstellungen fest. Diese sind grundsätzlich global gültig und können auf der Einstellungseite angepasst werden:

In den Einstellungen findest du eine eigene Seite für das WP Word Cloud Plugin - wunderbar!

Jeden dieser globalen Parameter kannst du auch in deinem Shortcode verwenden. So wir die globale Einstellung überschrieben. So ist die Hintergrundfarbe z.B. standardmäßig transparent eingestellt. Möchtest du sie für die aktuelle Word Cloud auf grün und halbtransparent ändern, übergibst du einfach den Parameter background-color folgendermaßen:

[ wp-word-cloud source-type="url" id="meine-word-cloud" background-color="rgba(0,255,255,0.5)" ]https://www.spiegel.de[ /wp-word-cloud ]

Eine genaue Beschreibung aller Parameter folgt jetzt:

Parameter

id

Dieser Parameter ist für jeden Shortcode, den du einfügst, verpflichtend! Die Id adressiert jede Word Cloud auf einer Seite oder in einem Beitrag. Damit ist es möglich, mehrere Word Clouds gleichzeitig einzubinden. Mit der Id kannst du außerdem das Aussehen der Word Cloud mit CSS steuern. Beispiel:

[ wp-word-cloud source-type="inline" id="wordcloud1" ]Lorem Ipsum[ /wp-word-cloud ]

[ wp-word-cloud source-type="inline" id="wordcloud2" ]Lorem Ipsum[ /wp-word-cloud ]

source-type

Damit legst du fest, um was für eine Quelle es sich handelt. Dieser Parameter ist verpflichtend. Die folgenden Quellen werden unterstützt:

source-type=inline

Der Text wird innerhalb des Shortcodes übermittelt, z.B:

[ wp-word-cloud source-type=inline id="demo" ]Lorem Ipsum[ /wp-word-cloud ]

source-type=url

Im Shortcode wird eine URL angegeben, von der Text abgerufen wird, z.B:

[ wp-word-cloud source-type=url id="demo" ]https://www.spiegel.de[ /wp-word-cloud ]

**source-type=**id

Im Shortcode wird eine Id übergeben, die auf eine Seite oder einen Beitrag deiner Webseite verweist, z.B:

[ wp-word-cloud source-type=id="demo" ]123[ /wp-word-cloud ]

source-type=sql

Im Shortcode wird eine SQL-Abfrage übergeben, die eine bereits gezählte Wortliste zurück gibt, z.B:

[ wp-word-cloud source-type=sql id="demo"]SELECT word,count FROM table;[ /wp-word-cloud]

source-type=tags

Die Word Cloud zeigt alle Tags deiner Seite an, hier musst du im Shortcode nichts weiter übergeben:

[ wp-word-cloud source-type=tags id="demo"]SELECT word,count FROM table;[ /wp-word-cloud]

source-type=custom-field

Im Shortcode wird auf ein custom field, also benutzerdefiniertes bzw. eigenes Feld verwiesen, z.B:

[ wp-word-cloud source-type=custom-field id="demo"]my-custom-field[ /wp-word-cloud]

Die Darstellung der eigenen Felder musst du im Gutenberg-Edito ggf. erst aktivieren. Klicke dazu das Punkt-Menü und dann ganz unten auf “Ansicht anpassen”. Es öffnet sich nun eine Liste, in der du die “eigenen Felder” aktivieren kannst:

Anzeigen der benutzerdefinierten Felder im Gutenberg-Editor

count-words

Wenn die im Shortcode angegebene Quelle einen kompletten Text enthält, müssen die Wörter darin erst gezählt werden. Dazu muss count-words auf 1 gesetzt werden. Ist count-words=0 gesetzt, erwartet das Plugin eine List mit gezählten Wörtern.

enable-frontend-edit

Ist dieser Parameter auf 1 gesetzt, wird auf der Seite ein Textfeld angezeigt. Das Textfeld enthält den Text, der mit dem Shortcode definiert wurde. Der Besucher kann den Text dann beliebig verändern oder eigenen Text hinzufügen, um so die Word Cloud selber zu steuern. Die Berechnung der Word Cloud findet im Browser statt. Im folgenden Beispiel kommt der Text von einem benutzerdefiniertem Feld im Backend. Er wird an das Frontend ausgeliefert und dort in der Word Cloud dargestellt. Gleichzeitig kann man den Text aber auch anpassen und die Wolke neu zeichnen lassen:

[ wp-word-cloud source-type="custom-field" enable-frontend-edit=1 id="demo"]my-custom-field[ /wp-word-cloud]

Ein Textfeld für die Besucher deiner Webseite

OCR - Texterkennung

enable-ocr

Ist dieser Parameter auf 1 gesetzt, kann der Benutzer auf der Webseite ein Bild hochladen oder mit der Kamera aufnehmen. Im Browser findet dann eine Text-Erkennung statt. Die Wörter werden dann gezählt und die Word Cloud darauf basierend gezeichnet. Wenn enable-frontend-edit nicht aktiv ist, hat dieser Parameter keine Wirkung.

[ wp-word-cloud source-type="custom-field" enable-frontend-edit=1 enable-ocr=1 id="demo"]my-custom-field[ /wp-word-cloud]

Für diese Funktionalität greift das Plugin auf die Tesseract-Bibliothek zurück. Diese ermöglicht die Texterkennung von abfotografierten Dokumenten in verschiedenen Sprachen. Die Texterkennung erfolgt komplett im Browser, also beim Besucher der Webseite. Das Bild wird nicht zum Server hochgeladen.

ocr-language

Mit diesem Parameter legst du fest, welche Sprache(n) das ORC-Modul unterstützen soll. Standardmäßig ist hier deu eingestellt. Du kannst mehre Sprachen angeben, wenn du sie mit einem + trennst, z.B. Deutsch + Englisch:

`[ wp-word-cloud source-type="custom-field" enable-frontend-edit=1 enable-ocr=1 ocr-language="deu+eng" id="demo"]my-custom-field[ /wp-word-cloud]`

Eine Liste aller unterstützten Sprachpakete findest du hier:

https://tesseract-ocr.github.io/tessdoc/Data-Files#data-files-for-version-400-november-29-2016

ocr-local-libraries

Das OCR-Modul lädt einige, größere Dateien von einem anderen Server nach, unter anderem auch die Sprachpakete. Du kannst diese Dateien auch auf deinem Server anbieten. Dazu musst du die folgenden Dateien herunterladen und im Unterordner “lib” innerhalb des Plugin-Ordners ablegen:

• [https://unpkg.com/tesseract.js@v2.0.0/dist/worker.min.js]( https://unpkg.com/tesseract.js@v2.0.0/dist/worker.min.js' defer=‘defer)
• [https://unpkg.com/tesseract.js-core@v2.0.0/tesseract-core.wasm.js]( https://unpkg.com/tesseract.js-core@v2.0.0/tesseract-core.wasm.js' defer=‘defer)

Außerdem benötigst du die von dir konfigurierten Sprachpakete. Diese kannst du hier für die Version 4 herunterladen . Die Sprachpakete gehören ebenfalls in den Unterordner “lib”. Außerdem musst du manuell die Dateiendung “.gz” anhängen.

Eingrenzen der Wortliste

min-word-length

Hiermit legst du fest, wie lang ein Wort mindestens sein soll, um beim Zählen berücksichtigt zu werden. Diese Einstellung wird nicht berücksichtigt, wenn du eine fertige Wortliste als Quelle angibst. In diesem Beispiel wird das Wort Foo beim Zählen ignoriert.

`[ wp-word-cloud source-type="inline" count-words=1 min-word-lenght=4 id="demo"]Lorem Ipsum Foo[ /wp-word-cloud]`

min-word-occurence

Mit diesem Parameter legst du fest, wie oft ein Wort mindestens vorkommen muss, um in der word cloud dargestellt zu werden. Diese Einstellung wird immer berücksichtigt, auch wenn du eine fertige Wortliste als Quelle angibst. Im Beispiel werden nur Wörter in der word cloud dargestellt, die mindestens 2 mal vorkommen:

`[ wp-word-cloud source-type="inline" count-words=1 min-word-occurence=2 id="demo"]Lorem Ipsum Foo[ /wp-word-cloud]`

black-list und enable-black-list

Die Blacklist enthält Wörter, die beim Zählen nicht berücksichtigt werden dürfen. Das können z.B. Funktionswörter oder Fremdwörter sein, die du nicht in der word cloud sehen möchtest. Die Wörter werden mit einem Leerzeichen getrennt angegeben. Wenn du den Parameter im Shortcode angibst, wird die globale Einstellung komplett ignoriert. Die Blacklist wird nur verwendet, wenn der Parameter enable-black-list auf 1 gesetzt ist. Im Beispiel wird das Wort “Lorem” beim Zählen ignoriert, das es sich auf der Blacklist befindet.

`[ wp-word-cloud source-type="inline" count-words=1 enable-black-list`=1 `black-list="Lorem" id="demo"]Lorem Ipsum Foo[ /wp-word-cloud]`

enable-custom-black-list

Ist dieser Parameter aktiviert, kann der Besucher deiner Webseite Wörter in der word cloud anklicken, um sie aus der word cloud zu entfernen. Die Wörter erscheinen dann unter der word cloud in einer “benutzerdefinierten” Blacklist. Wenn sie dort erneut angeklickt werden, erscheinen sie wieder in der word cloud.

Eine word cloud mit benutzerdefinierter Blacklist, so schön!

persistent-custom-black-list

Hiermit kannst du festlegen, dass die Blacklist erhalten bleibt, wenn der Besucher einen neuen Text in das Eingabefeld eingibt. Ist der Parameter deaktiviert, wird die benutzerdefnierte Blacklist gelöscht, sobald der Besucher einen neuen Text eingibt. Dieser Parameter ist nur wirksam, wenn auch das Textfeld aktiviert ist.

ignore-chars

Mit diesem Parameter legst du fest, welche Zeichen aus dem Text entfernt werden, bevor er gezählt wird. Hier wird ein regulärer Ausdruck dieser Form erwartet:

ignore-chars="\(\)\[\]\,\.;"

Auf diese Art kannst du ungewollte Satzzeichen, Sonderzeichen oder Steuerzeichen entfernen.

Erscheinungsbild anpassen

style

text-transform

Hiermit kannst du festlegen, dass der Text beim Darstellen in der word cloud groß oder kleingeschrieben werden soll. Dieser Parameter kann dementsprechend drei Werte annehmen:

• uppercas (alle Wörter groß schreiben)
• lowercase (alle Wörter klein schreiben)
• none (keine Änderung)

Diese word cloud nutzt als Ressource die aktuellen Mitteilungen von fefe :

[wp-word-cloud source-type=“url” id=“demo2” count-words=1 min-word-occurence=1 min-word-length=3 size-factor=100 min-alpha=0.5 count-words=1]https://blog.fefe.de[/wp-word-cloud]

Um das zu demonstrieren habe ich eine Datenquelle mit 1 Mio. Zeilen und 10 Dimensionen erzeugt. Der Drill-Down auf Ebene 8 dauert hier auf normaler Hardware über 20 Sekunden und das Ergebnis ist… nun ja: Für eine schnellen Überblick kaum zu gebrauchen:

Drill-Down auf die 8. Ebene einer Hierarchie mit hoher Kardinalität: Übersicht ade

Im Folgenden beschreibe ich einen Weg, wie man einen fokussierten Drill-Down ermöglicht, der weitaus performanter und vor allem übersichtlicher ist. Man könnte zwar die eingebaute Quick-Filter-Funktion nutzen, das ist dann aber relativ umständlich, da man je Ebene mindestens zwei Klicks benötigt und vor allem immer noch nicht übersichtlich:

Drill-Down bei mehreren Dimensionen einer Hierarchie unter Verwendung des Quick-Filters: Unpraktisch

Bevor ich die Schritte im einzelnen erkläre, möchte ich zeigen, was das Ziel der ganzen Übung sein soll:

Schematische Darstellung der Logik

Die Namen der einzelnen Dimensonen werden für jedes Level zusammengefasst. Jede Dimension in der Hierarchie wird außerdem durch einen Index repräsentiert, der die Tiefe wiederspiegelt. Dadurch entsteht ein Pfad nach dem Schema nameA.nameB.NameC.nameD.nameX usw. Diese Pfad soll als Filter dienen. So kann ich mit einem einzigen Filter mehrere Dimensionen abdecken.

Ein Klick auf eine Zeile im Arbeitsblatt “main” soll dafür sorgen, dass der Index für die aktuelle Ebene um 1 hochgezählt wird - man also tiefer in den Baum hineingeht. Außerdem wird der Pfad für die entsprechende Ebene als Filter genutzt. Dadurch erhalte ich eine Ansicht, die einem kombinierten Filter gleicht, immer nur die Zeilen anzeigt, die ich beim Drill-Down ausgewählt habe. Klicke ich auf das zweite Arbeitsblatt, wird der Index heruntergezählt, also immer die nächsthöhere Ebene angezeigt. Außerdem wird bei dem zusammengesetzten Pfad das letzte Element entfernt, wodurch sich gleichzeitig die Filterbedingung ändert.
Um diese Mechanik umzusetzen, benötigen wir also zwei Felder, eines enthält immer den aktuellen Index + 1 für die nächste Ebene und Index - 1 für die nächst höhere Ebene. Außerdem gibt es ein Feld, dass den aktuellen Pfad enthält, also z.B. nameA.nameB.nameC. Ein weiteres Feld enthält den nächsten Pfad, je nachdem wo der Nutzer klickt, also z.B. nameA.nameB.nameC.nameD und ein Feld enthält den Pfad für die zuvor ausgewählte Ebene, also z.B. nameA.nameB. Das ganze wird mit ein paar Aktionen und Filtern so miteinander kombiniert, dass der Benutzer interaktiv durch die Hierarchie reisen kann.
Klar soweit? Los geht’s:

Du benötigst zwei Arbeitsblätter und ein Dashboard, das die beiden Arbeitsbelätter beherbergt. Als Namen wähle ich “main” für die eigentliche Darstellung der KPIs und “go back” für die Navigation. Wir beginnen mit der Erstellung der beiden Parameter.
Der Parameter “current level index” enthält, entsprechend der Anzahl der Dimensionen, die Ziffern 1 bis 10. Der Parameter “level name concatenated” dient später als Filter-Element und enthält den oben erwähnten Pfad:

• 

  Parameter level name concatenated

• 

  Parameter current level index

Nun erstellst du einen Filter, der sich auf den Parameter “level name concatenated” bezieht. Das vereinfacht den weiteren Prozess ungemein, da du kein Filter-Aktion anlegen musst, sondern Tableau den Filter immer dynamisch anpasst. Dazu legst du einen Filter für das Arbeitsblatt “main” an und wählst im Reiter “Bedingung” die Option “nach Formel” aus. Als Formel verwendest du diese:

1[level name concatenated] = [current level filter]

So sollte der Filter dann in Tableau aussehen:

Filter mit einer Formel als Bedingung

Weiter geht es mit ein paar berechneten Feldern:

Das erste Feld nennt sich “current level”, dass den Parameter “current level index” nutzt um die entsprechende Dimension darzustellen. Die Formel dazu ist simpel:

 1IF     [current level index] = 1 THEN [Dimension1] 
 2ELSEIF [current level index] = 2 THEN [Dimension2]
 3ELSEIF [current level index] = 3 THEN [Dimension3]
 4ELSEIF [current level index] = 4 THEN [Dimension4] 
 5ELSEIF [current level index] = 5 THEN [Dimension5] 
 6ELSEIF [current level index] = 6 THEN [Dimension6] 
 7ELSEIF [current level index] = 7 THEN [Dimension7] 
 8ELSEIF [current level index] = 8 THEN [Dimension8] 
 9ELSEIF [current level index] = 9 THEN [Dimension9] 
10ELSEIF [current level index] = 10 THEN [Dimension10] 
11END

Als nächstes gibt es zwei Felder, die auch mit einer einfachen Formel auskommen: “previous level index” und “next level index”. Previous level index dient dazu, den Index herunter zu zählen. Hier könnte man sicherlich eine eleganter Lösung nutzen, um das Prinzip zu verdeutlichen, habe ich das mit einer einfachen Wenn-Dann-Bedingung realisiert:

 1IF [current level index] = 1 then 1
 2ELSEIF [current level index] = 2 then 1
 3ELSEIF [current level index] = 3 then 2
 4ELSEIF [current level index] = 4 then 3
 5ELSEIF [current level index] = 5 then 4
 6ELSEIF [current level index] = 6 then 5
 7ELSEIF [current level index] = 7 then 6
 8ELSEIF [current level index] = 8 then 7
 9ELSEIF [current level index] = 9 then 8
10ELSEIF [current level index] = 10 then 9
11END

Bei “next level index“läuft es genau anders rum:

 1IF     [current level index] = 1 THEN 2
 2ELSEIF [current level index] = 2 THEN 3
 3ELSEIF [current level index] = 3 THEN 4
 4ELSEIF [current level index] = 4 THEN 5
 5ELSEIF [current level index] = 5 THEN 6
 6ELSEIF [current level index] = 6 THEN 7
 7ELSEIF [current level index] = 7 THEN 8
 8ELSEIF [current level index] = 8 THEN 9
 9ELSEIF [current level index] = 9 THEN 10
10END

Weiter geht es mit den Pfaden, die wir für den Filter benötigen. Jetzt wird es etwas komplizierter: Das Feld “current level concat” fasst zunächst, entsprechen der aktuell ausgewählten Ebene, die Namen der vorherigen Ebenen zusammen. So entsteht der Pfad:

 1IF     [current level index] = 1  THEN [Dimension1] 
 2ELSEIF [current level index] = 2  THEN [Dimension1] + "." + [Dimension2]
 3ELSEIF [current level index] = 3  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3]
 4ELSEIF [current level index] = 4  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4]
 5ELSEIF [current level index] = 5  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5]
 6ELSEIF [current level index] = 6  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6]
 7ELSEIF [current level index] = 7  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7]
 8ELSEIF [current level index] = 8  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7] + "." + [Dimension8]
 9ELSEIF [current level index] = 9  THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7] + "." + [Dimension8] + "." + [Dimension9]
10ELSEIF [current level index] = 10 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7] + "." + [Dimension8] + "." + [Dimension9] + "." + [Dimension10]
11END

Das Feld “current level filter” ist ähnlich aufgebaut. Da der Filter sich aber strenggenommen auf die vorherige Eben bezieht, sieht der Pfad etwas anders aus:

 1IF     [current level index] = 1 THEN "." 
 2ELSEIF [current level index] = 2 THEN [Dimension1] 
 3ELSEIF [current level index] = 3 THEN [Dimension1] + "." + [Dimension2]
 4ELSEIF [current level index] = 4 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3]
 5ELSEIF [current level index] = 5 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4]
 6ELSEIF [current level index] = 6 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5]
 7ELSEIF [current level index] = 7 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6]
 8ELSEIF [current level index] = 8 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7]
 9ELSEIF [current level index] = 9 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7] + "." + [Dimension8]
10ELSEIF [current level index] = 10 THEN [Dimension1] + "." + [Dimension2] + "." + [Dimension3] + "." + [Dimension4] + "." + [Dimension5] + "." + [Dimension6] + "." + [Dimension7] + "." + [Dimension8] + "." + [Dimension9]
11END

Beim Feld “previous level concat” wird es schon etwas schwieriger, da ich hier immer das letzte Element des Pfades entfernen muss. Das erinnert ein wenig an eine aus dem Ruder gelaufene Excel-Funktion, ist leider aber - nach meinem aktuellen Kenntnisstand - nicht einfacher zu realisieren, da die Behandlung von Strings in Tableau eben eingeschränkt sit. Sachdienliche Hinweise werden dankbar entgegen genommen.

 1IF [current level index] = 1 THEN 
 2    "."
 3ELSEIF [current level index] = 2 THEN
 4    "."
 5ELSEIF [current level index] = 3 THEN
 6    LEFT([level name concatenated], FIND([level name concatenated], '.', 1) - 1)
 7ELSEIF [current level index] = 4 THEN
 8    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) - 1)
 9ELSEIF [current level index] = 5 THEN
10    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) + 1) - 1)
11ELSEIF [current level index] = 6 THEN
12    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1)) + 1) + 1) - 1)
13ELSEIF [current level index] = 7 THEN
14    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) + 1) + 1) + 1) + 1) - 1)
15ELSEIF [current level index] = 8 THEN
16    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) + 1) + 1) + 1) + 1) + 1) - 1)
17ELSEIF [current level index] = 9 THEN
18    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) + 1) + 1) + 1) + 1) + 1) + 1) - 1)
19ELSEIF [current level index] = 10 THEN
20    LEFT([level name concatenated], FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', FIND([level name concatenated], '.', 1) + 1) + 1) + 1) + 1) + 1) + 1) + 1) + 1) - 1)
21END

Das gröbste ist somit erledigt, du solltest nun die folgenden Felder und Parameter haben. Achte darauf, dass du die Felder als Dimension nutzt:

Alle berechneten Felder und Parameter auf einen Blick

Nun ziehst du die Felder “next level index”, “current level” und “current level concat” auf das Arbeitsblatt “main”, die Felder “previous level index” und “previous level concat” gehören auf das Arbeitsblatt “go back”.

• 

  Arbeitsblatt main mit allen nötigen Feldern

• 

  Arbeitsblatt “go back” mit allen nötigen Feldern

Das Dashboard mit Leben füllen

Abschließend geht es an die Aktionen um das Dashboard mit Leben zu füllen. Insgesamt benötigen wir vier Aktionen zur Änderung eines Parameters. Die ersten beiden Aktionen sorgen dafür, dass der aktuelle Index entsprechen hoch- und runtergezählt wird. Die Aktion “increase level index” nutzt als Quellblatt “main” sowie das Feld “next level index” und verweist auf den Parameter “current level index”. Und vice versa die Aktion “decrease level index” mit dem Quellblatt “go back”, dem Feld “previous level index” und ebenfalls dem Ziel-Parameter “current level index”:

• 

  Aktion zur Parameter-Steuerng: Den Level-Index um 1 erhöhen…

• 

  …und um eins verringern

Danach benötigen wir eine Aktion, um den Filter-Parameter “level name concatenated” zu setzen: Dieser erhält den Wert aus dem berechneten Feld “current level concat”, wenn man auf das Arbeitsblatt “main” klickt. Und beim Arbeitsblatt “go back” ist es wieder genau andersrum: Hier kommt der Wert aus dem Feld “previous level concat”:

• 

  Die Aktion um den Filter für die nächsttiefere Eben zu setzen…

• 

  … und für die darüberliegende Ebene

Et voila

Das war es. Du kannst nun das Dashboard nutzen, um beliebig durch deine Dimensionen zu klicken. Hier und da lässt sich das ganze sicherlich noch etwas optimieren. Zuerst kannst du z.B. die “Steuerfelder” ausblenden, um nur die relevanten Informationen zu präsentieren (in der Regel über rechte Maustaste “Kopfzeile ausblenden”). Außerdem kann man die Formeln optimieren und z.B. verhindern, dass der Nutzer tiefer klickt, als die verwendete Anzahl von Dimensionen. Das sind aber nur kleinere Baustellen. Das wichtigste Ziel sollte erreicht sein: Die Darstellung ist weitaus übersichtlicher und vor allem kann man nun in Sekundenbruchteilen bis zur letzten Eben navigieren.
Natürlich kann man das ganze auch mit einem Chart kombinieren, was der Sache noch etwas mehr Glanz verleiht. Auf Tableau Public habe ich eine Dashboard veröffentlicht, dass das ganze in Aktion zeigt. Aus Gründen ist die Datenquelle dort allerdings nur 100.000 Zeilen groß:

https://public.tableau.com/profile/nr1871#!/vizhome/focussedDrillDown/dashboard

Beim letzten Update auf Ubuntu 18.04 ließen sich die Parallels Tools gar nicht mehr installieren. Die Ursache dafür ist wohl irgendeine Inkompatibilität eines abhängigen Paketes mit dem neuen Linux-Kernel. Wie auch immer: Ich war die Sorgen leid und auf der Suche nach einer Alternative. Weshalb ich Docker stieß. Der Vorteil: Docker ist weitaus performanter und portabler. Der Nachteil: Um damit eine funktionierende Entwicklungsumgebung zu schaffen, kommt man um die Shell nicht herum. Das mitgelieferte UI Kitematic liegt noch als Beta vor und lässt einige Funktionen einfach vermissen. Es gibt also einige kleinere Fallstricke, die es zu überwinde galt. Was mir gelungen ist. Wie, das werde ich nun genauer erläutern. Viel Spass.

[caption id=“attachment_2166” align=“aligncenter” width=“300”] Kitematic - schön aber (noch) weitestgehend nutzlos[/caption]

Erste Schritte

Grundsätzlich kann man bei der  Installation der Docker-Anwendung nicht viel falsch machen: Account anlegen, Docker herunterladen, installieren, anmelden - fertig. Auf die zugrunde liegende Technologie will ich hier nicht weiter eingehen, das machen andere weitaus besser (z.B. ist diese Anleitung sehr zu empfehlen ).

Nur soviel soll gesagt sein: Du lädst ein Image herunter, dass du dann starten kannst. Dadurch erhältst du einen Container, der bestimmte Dienste bereitstellt. Dieser Container ist kein vollständiges Betriebssystem mit all seinem Ballast. So kannst du z.B. nicht ohne weiteres per SSH darauf zugreifen. Das funktioniert nur, wenn der entsprechende SSH-Dienst auch im Image vorgesehen ist. Das schöne an Docker ist aber, dass du das Image mit beliebigen Funktionalitäten über ein sogenanntes Dockerfile relativ unkompliziert nachrüsten kannst. Das erfordert zwar eine gewisse Umgewöhnung im Arbeitsablauf ab, bringt aber auch viele Vorteile mit sich.

Wer will kann sich mit der Kitematic UI durch die vorhandenen Docker-Images wühlen und auch direkt herunterladen. Diese stehen dann natürlich auch auf der Kommandozeile zur Verfügung. Mit docker image ls zeigst du alle verfügbaren Images an. Analog dazu listet docker container ls alle erstellten Container auf. Außerdem gibt es noch ein paar andere, für den Anfang ganz brauchbare Befehle:

# alle lokal verfügbaren Images auflisten docker image ls

alle gestarteten bzw. erzeugten Container auflisten

docker container ls

die Kommandozeile für den Container mit dem Namen “mysql” die Kommandozeile starten

docker exec -it mysql /bin/bash

für den Container mit dem Namen “mysql” das Setup anzeigen

docker inspect mysql

Für eine lokale Entwicklungsumgebung benötigt man zunächst einen HTTP- und einen MySQL-Server. Natürlich gehört zu jeder guten Entwicklungsumgebung auch ein Debugger - für PHP wäre das wohl xdebug. Ich nutze hier die beiden Images: nginx-php-fpm von Ric Harvey und das sehr aktuelle und offizielle MySQL-Image , die ich erstmal ganz unkompliziert über Kitematic herunterlade. Das nginx-Image werde ich schließlich mit einem Dockerfile anpassen um auch xdebug nutzen zu können.

[caption id=“attachment_2167” align=“aligncenter” width=“300”] Die Auswahl neuer Images über Kitematic ist sehr bequem[/caption]

Ab hier verlasse ich Kitematic allerdings wieder und werde Docker nur noch über die Kommandozeile und ein paar selbst geschriebene Scripte nutzen. Los gehts…

Den MySQL-Container starten

… es mit dem MySQL-Container. Da der nginx-Container auf MySQL zugreift, muss der MySQL-Container auch zuerst dasein. Der Aufruf dafür sieht folgendermaßen aus:

docker run \ –name mysql \ –publish 3306:3306 \ –volume /Users/nicky/Development/MySQL:/var/lib/mysql \ –env MYSQL_ALLOW_EMPTY_PASSWORD=yes \ –env MYSQL_ROOT_HOST=% \ –detach \ –default-authentication-plugin=mysql_native_password \ mysql

Mit –name vergebe ich einen festen und vor allem lesbaren Namen. Ohne diesen Parameter würde Docker eine Id anlegen, die den Zugriff später aber unnötig kompliziert macht. Der Parameter --publish legt fest, welcher Port “von draußen” auf einen Port im Docker-Container gemappt wird. Da sich die Dateien für die Datenbank physikalisch natürlich nicht im Docker-Container, sondern im Dateisystem vom Host befinden, muss ich dem Container mitteilen, wie er darauf zugreifen kann. Das passiert mit dem Parameter --volume. Damit kann ich nich nur Ordner im Container verfügbar machen, sondern auch Dateien. Das ist ganz praktisch, um z.B. Configurations-Dateien von außerhalb beim Start des Containers mitzuliefern.

Der Parameter --env dient dazu, Umgebungsvariablen zu setzen. Diese sind natürlich abhängig vom verwendeten Container. Für den MySQL-Container möchte ich hier zwei Parameter übergeben: Ich will eine Root-Benutzer ohne Passwort anlegen (MYSQL_ALLOW_EMPTY_PASSWORD) (das mag unsicher erscheinen, da ich hier aber lokal nur mit Testdaten arbeite, ist das erstmal einfach nur pragmatisch). Außerdem soll sich jeder Client verbinden können, also setzte ich MYSQL_ROOT_HOST auf %.

Eine Besonderheit ist der Parameter default-authentication-plugin. Wenn du ein Root-Passwort vergibst, solltest du zusätzlich diesen Parameter setzen. Zur Erklärung: Es handelt sich hier um ein MySQL 8-Image. Dort wird als Authentifizierungs-Methode caching_sha2_password verwendet, was sich mit Docker leider nicht verträgt und mit dieser Fehlermeldung quittiert wird:

Unable to load authentication plugin ‘caching_sha2_password

Und schließlich gibt es noch den Parameter –detach, der einfach dafür sorgt, dass der Container im Hintergrund gestartet wird.

Das war es fast. Was jetzt noch fehlt, ist der Name des Images, dass die Grundlage für deinen neuen Container bilden soll: mysql. Wenn das Image lokal nicht vorhanden ist, lädt Docker es hilfsbereiterweise einfach herunter.

Es empfiehlt sich, den Aufruf in ein Shell-Script zu packen und diese Zeilen voranzustellen. Beim Aufruf wird also ein vorhandener Container erst gestoppt und gelöscht und dann neu gestartet:

#!/bin/bash docker stop mysql docker rm mysql docker run \ –name mysql \ -p 3306:3306 \ -v /Users/nicky/Development/MySQL:/var/lib/mysql \ -e MYSQL_ALLOW_EMPTY_PASSWORD=yes \ -e MYSQL_ROOT_HOST=% \ -d \ –default-authentication-plugin=mysql_native_password \ mysql

Et voilà: Ein MySQL-Server im Docker-Container auf Knopfdruck!

Den HTTP-Container starten

Am Vorgehen ändert sich nicht viel. Auch für den nginx-Server erstelle ich mir ein kleines Script. Dieses befindet sich aber in einem Unterordner meiner Wordpress-Installation. Mit dem Platzhalter ${PWD} im Parameter --volume kann ich Docker das aktuelle Verzeichnis mitgeben. Dadurch kann  ich das Script auch innerhalb andere Wordpress-Installationen verwenden (und muss lediglich den Namen des Containers anpassen). Hier sorge ich also dafür, dass Docker das aktuelle Verzeichnis als Root-Verzeichnis für den HTTP-Server nutzt. Außerdem liefere ich eine eigene ini-Datei für PHP mit. Wichtig ist außerdem die Verknüpfung zu meinem zuvor erstellen MySQL-Container über den Parameter --link. Der Rest wird analog des ersten Containers vorgegeben: Port, Name, Image, usw.

#!/bin/bash docker stop nickyreinert-de docker rm nickyreinert-de docker run \ –link mysql \ –name nickyreinert-de \ –volume ${PWD}/dev/wordpress.ini:/usr/local/etc/php/conf.d/uploads.ini \ –volume ${PWD}:/var/www/html \ –publish 80:80 \ –detach \ richarvey/nginx-php-fpm

xdebug installieren

Leider liefert das nginx-Image kein xdebug mit. Bzw: Zurecht - der Sinn des ganzen Konzeptes ist es ja, schlanke Container nutzen zu können. Eine All-In-One-Lösung entspräche letztlich ja wieder einer kompletten virtuellen Maschine. Für mich jedenfalls heißt das, dass ich das nginx-Image nun irgendwie mit xdebug füttern muss. Das passiert mit docker build. Dazu benötige ich zunächst ein Dockerfile, dass auch genau so heißt und folgendermaßen aufgebaut ist - Erklärung folgt darunter:

FROM richarvey/nginx-php-fpm

RUN apk add –no-cache –virtual .phpize-deps $PHPIZE_DEPS RUN apk add –no-cache nano

RUN pecl install xdebug RUN echo ‘zend_extension = /usr/local/lib/php/extensions/no-debug-non-zts-20170718/xdebug.so’ » /usr/local/etc/php/php.ini RUN touch /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_enable=1 » /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_autostart=1 » /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_connect_back=0 » /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_host=192.168.0.11 » /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_port=9000 » /usr/local/etc/php/conf.d/xdebug.ini; \ echo xdebug.remote_log=/tmp/php-xdebug.log » /usr/local/etc/php/conf.d/xdebug.ini;

Zunächst einmal lege ich mit FROM fest, welches Images als Grundlage genutzt werden soll - in meinem Fall also nginx-php-fpm von richarvey. Mit RUN übergebe ich dann, zum Image passende, Befehle. So könnte ich xdebug zum Beispiel einfach mit pecl install xdebug installieren lassen. Du wirst dann aber recht schnell feststellen, dass das nicht ohne weiteres funktioniert. PHP ist in diesem Docker-Image natürlich nur mit den wichtigsten Paketen eingerichtet, phpize gehört so z.B. nicht dazu und der Aufruf würde mit folgender Fehlermeldung quittiert werden:

Cannot find autoconf. Please check your autoconf installation and the # $PHP_AUTOCONF environment variable. Then, rerun this script.

Die Lösung ist, phpize im Voraus mit allen notwendigen Abhängigkeiten zu installieren. Dazu dient der Aufruf

RUN apk add –no-cache –virtual .phpize-deps $PHPIZE_DEPS

Das das nicht immer so umfangreich vonstatten gehen muss, soll die Installation des Texteditors nano zeigen: Man kann gewünschte Pakete auch einfach mit apk add zum Docker-Image hinzufügen. Der apk-Parameter --virtual besagt, dass die genannten Pakete zu einem “virtuellen Paket” hinzugefügt werden, dass sich dann mit apk del leicht wieder entfernen lässt. Danach schließlich kann xdebug mit pecl install installiert werden. Die letzten beiden RUN-Aufrufe sorgen dafür, dass eine Standard-Konfiguration für xdebug eingerichtet wird. Hier wird es tatsächlich noch etwas tricky, wenn es um den remote_host geht. Docker lässt den Container später in einem eigenen Netzwerk laufen. Der Docker-Host, also in meinem Fall OS X,erhält dafür eine eigene IP-Adresse, wie z.B. 172.17.0.1. Das Problem: Das ist nicht die IP-Adresse, unter der OS X bzw. der Debug-Client (z.B. Visual Studio Code) erreichbar ist. Jeder Debug-Versuch wurde (in meinem Fall) in /tmp/php-xdebug.log mit folgender Fehlermeldung quittiert:

W: Creating socket for ‘127.0.0.1:9000’, poll success, but error: Operation in progress (29).

Der Remote-Host ist also die tatsächliche IP-Adresse deines Hosts, unabhängig von Docker. Hier demnach die IP-Adresse 192.168.0.11.

Zum Abschluss muss das Dockerfile nur noch verarbeitet werden. Das passiert mit folgendem Aufruf:

docker build –tag nginx-php-fpm-xdebug .

Mit dem Parameter --tag gibst du dem modifizierten Image einen eigenen Namen. Der letzte Parameter - ein Punkt - zeigt docker, in welcher Datei sich die Build-Anweisung befindet. Docker sucht standardmäßig nach einer Datei mit dem Namen Dockerfile. Deshalb verweise ich mit dem Punkt einfach nur auf den aktuellen Ordner, in dem sich diese Datei auch befindet.

Docker wird nun die Anweisungen aus dem Dockerfile verarbeiten und ein neues Image erzeugen. Der erste Aufruf wird etwas länger dauern. Wenn du an dem Dockerfile nur geringfügige Änderungen vornimmst und den build-Prozesse erneut startest, ist Docker so clever und nimmt nur die notwendigen Änderungen vor - alles andere befindet sich bereits in einer Art “Zwischenspeicher”.

Denke nun daran, den oben bereits zusammengebauten Container-Aufruf des HTTP-Servers den Image-Name anzupassen: nginx-php-fpm-xdebug!

Visual Studio Code

Der Vollständigkeit halber möchte ich nun noch die Schritte dokumentieren, die bei Microsofts Visual Studio Code (VSC) notwendig sind. Hier installiert man zunächst das Paket PHP Debug. Im Debug-Bereich fügt man dann eine neue Konfiguration hinzu, die VSC mitteilt, unter welcher IP-Adresse xdebug erreichbar ist - nämlich 127.0.0.1 und dem üblichen Port: 9000:

{ // Use IntelliSense to learn about possible attributes. // Hover to view descriptions of existing attributes. // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 “version”: “0.2.0”, “configurations”: [ { “name”: “Listen for XDebug”, “type”: “php”, “request”: “launch”, “port”: 9000, “host”: “127.0.0.1” } ] }

Fertig. Mit einem Klick auf den grünen Playbutton wird VSC sich nun mit xdebug verbinden.

[caption id=“attachment_2199” align=“aligncenter” width=“300”] Visual Studio Code - den Debugger starten[/caption]

Fazit

Docker hat mich voll überzeugt. Ich bereue es, dass ich nicht schon früher umgestiegen bin. Es läuft sauber und wenn man das Konzept erstmal verstanden hat, ist es auch sehr intuitiv zu bedienen und lässt vor allem keine Wünsche auf. Im Nachhinein betrachtet hat mich die komplette Einrichtung der virtuellen Maschine mit Ubuntu unter Parallels auch weitaus mehr Zeit - und Nerven! - gekostet. Was jetzt noch fehlt, ist das etwas dynamischere Verwalten mehrerer lokaler Websiten mit Docker. Dazu komme ich später - stay tuned.

Referenzen

Mein Dank gilt Caleb Sotelo , von wo ich einen Großteil der Scripte habe. Ein Teil des Dockerfiles stammt von philipphauer.de . Danke!

Was ist Bash?

Bash steht für “Bourn again shell” und ist eine Erweiterung der älteren Bourne-Shell, eine Shell die auf Unix-(ähnlichen) Systemen als Benutzerschnittstelle dient. Und diese ist vor allem daran erkennbar, dass die Steuerung des Systems nur über die Tastatur, ohne Maus und Fenster funktioniert.

Seit der Version 10.3 ist Bash auch Bestandteil von Mac OS X und bringt damit eine Menge Vorteile für die Arbeit auf der Kommandozeile mit sich.

Die Bash Konfigurationsdateien

Die globalen Einstellungen für die Bash befinden sich in der Datei /etc/bashrc und der /etc/profile. Wer Einstellungen auf bestimmte Benutzer beschränken will, kann im Benutzerverzeichnis (du gelangst mit cd ~ dorthin) eine Datei mit dem Name .profile, .bash_login oder .bash_profile anlegen. Beachte, dass .profile nur geladen wird, wenn .bash_login nicht existiert, welche wiederum durch .bash_profile überschrieben wird. Das gilt allerdings nicht, wenn du dich als root-Benutzer anmeldest - dann wird nur die Datei .profile gelesen. Der Grund ist, dass der Root-Benutzer nicht bash sondern sh ausführt, wodurch nur die ~/.profile-Datei berücksichtigt wird.

Hierarchie der Bash-Konfigurations-Dateien

Daneben gibt es theoretisch auch die Möglichkeit, im Benutzerverzeichnis eine Datei mit dem Namen .bashrc anzulegen. Diese wird jedoch nur dann geladen, wenn Bash ausgeführt wird, ohne dass sich ein Benutzer dazu anmeldet (die sogenannte non-login-shell). Im OS X-Umfeld wird das aber nicht benötigt. Du kannst das erzwingen, indem du auf der Kommandozeile /bin/bash ausführst - wir wollen die jetzt schon komplizierte Geschichte aber nicht unnötigen verkomplizieren. ;)

Die Bash aufhübschen

Nach der langweiligen aber notwendige Theorie, gibts jetzt ein paar Zeilen Code, mit denen die Kommandozeile gleich viel besser aussieht. Ich hab aus oben genannten Gründen das Ganze in die Datei ~/.profile gepackt. Zunächst einmal ein paar Aliase um die Verzeichnislisten etwas übersichtlicher zu gestalten oder auch das oft benutzte cd (change dir) zu vereinfachen.

 1alias l='ls -alCFGA'
 2alias ll="ls -CFGla"
 3alias h="history"
 4alias .="cd ~"
 5alias ..="cd .."
 6alias ...="cd ../.."
 7# -p: erzeuge Unterverzeichnis, falls sie nicht existieren
 8# -v: gebe erzeugtes Verzeichnis zurück
 9alias mkdir="mkdir -pv"
10# grep Ausgabe farbig gestalten
11alias grep='grep --color=auto'
12alias fgrep='fgrep --color=auto'
13alias egrep='egrep --color=auto'
14# das aktuelle Verzeichnis im Finder öffnen
15alias f='open -a Finder ./'

Die folgende Zeile ist kein Alias sondern eine Funktion. Damit wird ein Verzeichnis (mit allen benötigten Unterverzeichnissen erstellt) und dann mit cd direkt in das Verzeichnis gewechselt:

1mcd () { mkdir -p "$1" && cd "$1"; }

Als nächstes will ich die Darstellung der zuletzt benutzten Befehle (history bzw. jetzt h) etwas anpassen:

1# Duplikate ignorieren
2HISTCONTROL=ignoreboth
3# Befehle anhängen und die Historie nicht jedes mal neu überschreiben
4shopt -s histappend
5# die maximale Größe bzw. Länge der Historie erhöhen
6HISTSIZE=1000
7HISTFILESIZE=2000

Der folgende Befehl sorgt dafür, dass sich die Anzahl der dargestellten Spalten und Zeilen an die Fenstergröße anpasst. Die Funktion sollte per default aktiviert sein, zur Sicherheit legen wir das hier trotzdem fest! Mit dem Parameter -u kann die Option übrigens wieder deaktiviert werden.

1shopt -s checkwinsize

Hiermit wird das Aussehen und die Farbe der Kommandozeile geändert. Ich hab mich für eine relativ bunte Variante entschieden. Die Einstellung für den sog. Prompt wird in der globalen Variable PS1 (prompt statement 1) gespeichert. Die folgenden Parameter sind hier geläufig:

• \u - Benutzername
• \h - Name des Hosts / Computers
• \w - der komplette aktuelle Pfad
• \n  - Ein Zeilenumbruch

Mit PS2, PS3, PS4 lassen sich noch andere Prompts konfigurieren, wie z.B. der für interaktive Eingaben in Bash-Scripten. Die Variable PROMPT_COMMAND wird sogar noch vor PS1 dargestellt. Wer mehr dazu erfahren möchte, schaut einfach mal dort vorbei .

1export PS1="$(date +%k:%m:%S) \[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ "
2
3# Diese Konstanten steuern die Farben für die Ausgabe von cd.
4export CLICOLOR=1
5export LSCOLORS=ExFxBxDxCxegedabagacad

Das ganze sieht dann so aus:

Eine bunte aber informative Kommandozeile

Diese Funktion zeigt alle Prozesse, die unter dem aktuellen Benutzer aktiv sind:

1me() { ps $@ -u $USER -o pid,%cpu,%mem,start,time,bsdtime,command ; }

Als nächstes ein paar Aliase um das Netzwerk ein bisschen einfacher im Griff zu behalten:

 1# alle Verbindungen, die gerade "Lauschen"
 2alias cons='sudo lsof -i | grep LISTEN'
 3# alle offenen Sockets
 4alias socks='sudo /usr/sbin/lsof -i -P'
 5# alle offenen TCP/IP-Sockets
 6alias tsocks='lsof -i'
 7# alle offenen UDP-Sockets
 8alias usocks='sudo /usr/sbin/lsof -nP | grep UDP'
 9# alle offenen TCP-Sockets
10alias lsocks='sudo /usr/sbin/lsof -nP | grep TCP' 
11# grundlegende Netzwerkeinstellungen
12alias net='ipconfig getpacket en0'
13
14# den DNS-Cache leeren
15alias cleardns='dscacheutil -flushcache'

Die ganzen Inhalte gibt es hier noch einmal in kompakter Version:

 1case $- in
 2    *i*) ;;
 3      *) return;;
 4esac
 5
 6alias l='ls -alCFGA'
 7alias ll="ls -CFGla"
 8alias h="history"
 9alias .="cd ~"
10alias ..="cd ..; pwd"
11alias ...="cd ../..; pwd"
12alias mkdir="mkdir -pv"
13alias grep='grep --color=auto'
14alias fgrep='fgrep --color=auto'
15alias egrep='egrep --color=auto'
16alias f='open -a Finder ./'
17
18HISTCONTROL=ignoreboth
19shopt -s histappend
20HISTSIZE=1000
21HISTFILESIZE=2000
22
23shopt -s checkwinsize
24
25case "$TERM" in
26    xterm-color|*-256color) color_prompt=yes;;
27esac
28
29export PS1="$(date +%k:%m:%S) \[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ "
30export CLICOLOR=1
31export LSCOLORS=ExFxBxDxCxegedabagacad
32
33mcd () { mkdir -p "$1" && cd "$1"; }
34me() { ps $@ -u $USER -o pid,%cpu,%mem,start,time,bsdtime,command ; }
35
36alias cons='sudo lsof -i | grep LISTEN'
37alias socks='sudo /usr/sbin/lsof -i -P'
38alias tsocks='lsof -i'
39alias usocks='sudo /usr/sbin/lsof -nP | grep UDP'
40alias lsocks='sudo /usr/sbin/lsof -nP | grep TCP'
41alias net='ipconfig getpacket en0'
42alias cleardns='dscacheutil -flushcache'

Schon mal was von Telegramm gehört oder gar einem Telegramm-Bot gehört? Nein? Macht nichts. Telegramm ist ein Messenger, wie Whatsapp oder Threema. Der große Vorteil von Telegramm gegenüber Whatsapp ist die Plattforum-Unabhängigkeit. Es gibt nicht nur Apps für Android und iOs, auch unter OS X (Mac) und Windows lässt sich Telegramm unkompliziert nutzen. Bei Whatsapp war das bisher nur über den Browser möglich, Threema bietet diese Möglichkeit gar nicht an.

Außerdem bietet Telegramm ein sehr umfangreiche API an, die noch dazu sehr gut dokumentiert ist. Damit lassen sich sogenannte Telegramm-Bots entwickeln. Diese Bots können dann von den Nutzern mit @einBot angesprochen werden, um alle Möglichen Aufgaben auszuführen. Einer der bekanntesten ist vermutlich der @gif-Bot, der die Plattform giphy.com durchsuchen kann und die Ergebnisse in den Chat-Verlauf schicken kann. Und diese Art von Bots lassen sich auch selber entwickeln und anbieten. Unter anderem auch mit PHP.

Wer die Kommunikation mit Telegramm nicht komplett von vorne aufbauen will, kann auf eine Bibliothek [von Longman auf github.com]( zugreifen. Für meinen Geschmack ist diese leider etwas zu schlecht dokumentiert und mitunter etwas durcheinander organisiert. Noch dazu wird sie offenbar nur sporadisch betreut. Dennoch gibt es ein relativ großes Repository mit Beispielen, was definitiv sehr hilfreich  ist. Etwas verwirrend sind die beiden Repositories, die da Core und Manager heißen. Der Manager ist nur eine Art Wrapper für das Core-Repository. Dessen Nutzung erleichtert die Einrichtung und Entwicklung des Bots um ein vielfaches und bietet z.B. eine zentrale Datei (manager.php) an, um alle Funktionen zu steuern. Beim Core werden die jeweiligen Bot-Funktionen über verschiedene Dateien gesteuert.

Was ist das Ziel?

Was ist also der Plan? Wir bauen uns einen Telegramm-Bot, mit dem sich Amazon nach Produkten durchsuchen lässt. Das Ergebnis wird in einem Grid dargestellt. Wählt man ein Element aus, erscheint es mit Link zum Produkt im Chat-Verlauf. Und mit einer Analytics-Plattform soll das ganze

Um deinen eigenen Bot betreiben zu können brauchst du natürlich erstmal Telegramm und außerdem einen Web-Server und eine Domain für die du ein SSL-Zertifikat einrichten musst. Außerdem solltest du composer installiert haben und so ungefähr wissen, wie man damit umgeht.

Anmelden eines Bots

Zunächst musst du deinen neuen Telegramm-Bot anmelden. Dazu nutzt du den BotFather ( BotFather) . dem du mit dem Befehl /newbot dazu bringen kannst, einen neuen Bot zu registrieren. Zuerst wird ein Name für den Bot verlangt - das ist allerdings noch nicht der Name, mit dem der Bot später auch angesprochen wird. Das ist erst der sogenannte username, der im 2. Schritt verlangt wird. Ich nenne meinen Bot @buecherBot.

Leider gibt es hier eine Restriktion: Der Name muss mit bot enden. Wer einen kurzen Namen wie @gif oder @youtube nutzen möchte, muss dazu vermutlich etwas mehr Aufwand betreiben. Als nächstes rufst du die Einstellungen des Bots auf, indem du das Inline-Menü mit /mybots öffnest.

Für unseren Bot solltest du zunächst den Inline-Mode aktivieren. Damit kannst du den Bot im Textfeld direkt ansprechen. Das gehst du über den Punkt Bot-Settings zum Inline-Mode und aktivierst diesen.

[caption id=“attachment_1655” align=“aligncenter” width=“300”] Inline-Mode für den Telegramm-Bot aktivieren[/caption]

Schließlich kannst du Allow Groups auf Nein setzen und die Group Privacy aktivieren. Da der Bot noch nicht in Gruppen aktiv sein soll, muss er weder Mitglied von Gruppen sein noch deren Nachrichten mitlesen.

Als nächstes lässt du dir den API-Schlüssel anzeigen, damit du auch von außen mit dem Bot kommunizieren kannst. Der API-Schlüssel befindet sich im obersten Menü und ist folgendermaßen aufgebaut:

123123123:128390123jKF19082_1293123123

Das war es, was die Vorbereitung angeht. Weiter geht es mit PHP und einer kleinen Bot-Logik.

Dem Bot mit PHP Leben einhauchen

Als Library bzw. Framework nutzen wir das  Telegram-Bot-Repository von Longman bzw. den dazugehörigen  Manager , eine Art Wrapper, der die Steuerung etwas erleichtert.Damit du für den ersten Start bereits eine gute Grundlage hast, solltest du dir die Beispiel-Dateien von github herunterladen. Auf der github-Seite wird zwar die Einstellung für die composer.json vorgegeben, allerdings hat der checkout damit bei mir nicht funktioniert. Mit folgenden Parametern klappte es dann:

{ “require”: { “php-telegram-bot/telegram-bot-manager”: “^1.2”, “longman/telegram-bot”: “0.52 as 0.48” } }

Nachdem composer alle Abhängigkeiten heruntergeladen hat (composer install), muss man sich in der manager.php an die Grundeinstellungen machen. (Es kann passieren, dass du auf deinem System einige PHP-Module installieren musst. Composer wird dir die Namen der Module allerdings nennen. Du kannst sie dann relativ unkompliziert mit z.B. apt-get install php7.0-b_cmath php7.0-curl herunterladen und aktivieren.) Außerdem werde ich ein paar Änderungen an der Datei InlinequeryCommand.php_ aus dem Ordner Commands aus dem Beispiel-Repository vornehmen.

Aber zuerst zur manager.php. Hier solltest du die folgenden Einstellungen vornehmen:

• bot_username - der Benutzername deines Bots, ohne das führende @

• api_key - der API-Schlüssel, den dir der Bot-Father gegeben hat

• secret - ein selbst erzeugtes Passwort um die Datei vor Zugriffen von außen zu schützen - die PHP-Datei liegt ja auf deinem öffentlichen Server und kann theoretisch von überall aufgerufen werden.

• webhook->url - hier trägst du die URL zur manager.php-Datei ein, also https://telegramm.example.com/manager.php

• commands->paths - diese Zeile muss auskommentiert sein und zu einem Pfad verweisen, der deine Bot-Commandos enthält. Wenn du dich an dem Bot-Example orientierst, sieht diese Einstellung so aus:

        'commands' => \[
           // Define all paths for your custom commands
           'paths'   => \[
               \_\_DIR\_\_ . '/Commands'
           \]
  

Als nächstes kannst du noch ein paar zusätzliche Änderungen vornehmen, die aber für die Funktion des Bots nicht wichtig sind:

• max_connections - offensichtlich die Anzahl der maximal zulässigen Verbindungen
• logging - diese Zeilen kannst du aus-kommentieren, um das Logging zu aktivieren, gerade in der Anfangsphase ist das ganz nützlich
• limiter - die Telegram-API lässt natürlich nur eine begrenzte Anzahl von Anfragen zu, um das eigene System zu schützen, offenbar bringt das Framework eine Funktion mit, um das Erreichen des Limits bestmöglich zu vermeiden - wie das funktioniert, kann ich nicht sagen, da dazu auch nicht mehr in der Doku steht, ich hab es erstmal aktiviert

Grundsätzlich war es das erstmal, was die Voreinstellungen betrifft. Jetzt kannst du den sog. webhook aktivieren. Dazu rufst du die manager.php im Browser auf, wie z.B.

https://telegramm.example.com/manager.php

Den Zugriff von außen beschränken

Wenn du alles richtig gemacht hast, erscheint jetzt erstmal ein Fehler. Und das ist auch gut so - denn schließlich soll der Zugriff von außen ja nicht jedem gewährt werden.

Fatal error: Uncaught TelegramBot\TelegramBotManager\Exception\InvalidAccessException: Invalid access in …

Also packst du noch das secret-Token an die URL, dass du weiter oben in der manager.php angegeben hast (nicht den API-Schlüssel von Telegramm!). Und damit du auch eine Aktion auslöst, setzt du erstmal den webhook mit dem Parameter a=set:

https://telegramm.example.com/manager.php?s=123123123&a=set

Dein Webhook für den Bot ist nun aktiv. Da du in der manager.php außerdem schon den Ordner commands freigegeben hast, kann der Bot nun schon auf Inline-Anfragen antworten. Im Telegramm-Client kannst du nun deinen Privat-Chat öffnen (“Gespeichertes”) und den Telegramm-Bot mit @buecherBot ansprechen. Der Bot sollte nun, wenn alles korrekt eingerichtet, so antworten, wie es in der Datei InlinequeryCommand.php vorgegeben ist. Nämlich mit einer sehr einfache 3-zeiligen Liste.

Um nun ein Ergebnis von der Amazon API als Bilder-Liste darzustellen, habe ich InlinequeryCommand.php ein wenig angepasst. Zuerst benötigen wir die entsprechende Klasse, um nicht nur mit Text sondern auch mit Bildern zu antworten:

use Longman\TelegramBot\Entities\InlineQuery\InlineQueryResultPhoto;

Außerdem habe ich den Aufbau des Antwort-Objektes etwas vereinfacht (ich werde hier nicht weiter ins Detail gehen, auf $this->apiResult gehe ich später ein).

foreach ($this->apiResult->items as $item) {

$this->inlineQueryResult[] = new InlineQueryResultPhoto(array( ‘id’ => sizeof($this->inlineQueryResult), ’title’ => ‘Search: ’ . $query, ‘description’ => ‘Info: ’ . $information, ’thumb_url’ => $thumbUrl, ‘photo_url’ => $imageUrl, ‘caption’ => $linkUrl ) );

}

$data[‘results’] = ‘[’ . implode(’,’, $this->inlineQueryResult) . ‘]’;

return Request::answerInlineQuery($data);

Grundsätzlich war es das schon. Du kannst nun noch alle möglichen anderen Funktionen des Bots nutzen. Schau dir dazu einfach den Commands-Ordner des Example-Repository an. Die Auswahl ist sehr groß, für meine Zwecke soll es aber erstmal bei der Inline-Query bleiben.

Eine Suchanfrage zu Amazon schicken

Natürlich soll derTelegramm-Bot nun auch in der Lage sein, Anfragen der Benutzer zu Amazon zu schicken und mit einem vernünftigen Suchergebnis zu antworten. Zunächst benötigt man dafür einen Partner-Account bei Amazon . In den Einstellungen kann man sich dann ein Schlüsselpaar erstellen um die Suchanfragen zu authentifizieren. Und auch für die Suchanfrage selber gibt es eine PHP-API, nämlich  apai-io von exeu . Die Einrichtung und der Aufbau sind relativ einfach. Nachdem composer die notwendigen Dateien heruntergeladen hat, packt man - wie üblich - ein paar Zeilen in eine PHP-Datei und hat die erste Anfrage an die Amazon-API fertig:

<?php ini\_set('display\_errors', 1);

require\_once \_\_DIR\_\_ . '/vendor/autoload.php';

define('AWS\_API\_KEY', 'AKAKAKAKAKAKAKA');
define('AWS\_API\_SECRET\_KEY', 'KALSKDLASKDLASDKLASDKLASKLDKASLDASDL
define('AWS\_ASSOCIATE\_TAG', 't0000-21');

use ApaiIO\\Configuration\\GenericConfiguration;
use ApaiIO\\Operations\\Search;
use ApaiIO\\ApaiIO;

$conf = new GenericConfiguration();
$client = new \\GuzzleHttp\\Client();
$request = new \\ApaiIO\\Request\\GuzzleRequest($client);

$conf
	->setCountry('de')
	->setAccessKey(AWS\_API\_KEY)
	->setSecretKey(AWS\_API\_SECRET\_KEY)
	->setAssociateTag(AWS\_ASSOCIATE\_TAG)
	->setRequest($request);
	
$apaiIO = new ApaiIO($conf);

$search = new Search();
$search->setCategory('DVD');
$search->setActor('Bruce Willis');
$search->setKeywords('Stirb Langsam');

$response = $apaiIO->runOperation($search);

$results = simplexml\_load\_string( $response ); 

Leider gestalten sich die ersten Versuche mit der API etwas schwieriger. Nutzt man den Beispiel-Code, liefert das ganze Script nur einen sehr langen String zurück. In der weiterführenden [Dokumentation]( wird zwar ein setResponseTransformer beschrieben (siehe auskommentierte Zeile oben). Doch auch dann ist die Antwort nicht nutzbar. Das Suchergebnis bleibt weiterhin ein langer String. Erst Issue 48 gibt einen Hinweis auf die Lösung: new SimpleXMLElement.  Jetzt erhalte ich ein XML-Object, in dem ich mich mit einer Schleife durch das Ergebnis arbeiten kann. Oder man greift auf die hier verwendete Funktion   simplexml_load_string zurück - mein Favorit.

Nun geht es darum, die Antwort in eine Schleife zu packen, um die notwendigen Informationen zu extrahieren. Das Suchergebnis muss also vorbereitet und zurück an denTelegramm-Bot geschickt werden.

Die Hochzeit - Amazons-Antwort an denTelegramm-Bot weiterleiten

Bisher war die Amazon-Funktionalität in eine andere Datei ausgelagert. Also müssen erstmal Zugangsdaten und die Abhängigkeiten in die InlineQueryCommand.php übernommen werden. Ich mach mir das Leben nicht unnötig schwer, und packe das alles in die InlinequeryCommand.php. Sauberer wäre es vielleicht, die initiale bot-Klasse etwas zu erweitern. Außerdem  muss die Anfrage an den Bot an die Amazon-API durchgeschliffen werden. Wenn der Benutzer nur einen Suchbegriff angibt (Bruce Willis), wird danach in allen Kategorien gesucht. Wer die Suche einschränken möchte, muss dem Suchbegriff die entsprechende Kategorie voranstellen. Also z.B.: Books:Bibel Das ganze sieht dann in etwa so aus:

$request = explode(’:’, trim($requestString));

if (sizeof($request) == 1) {

$category = 'All';
$keywords = trim($request\[0\]);

} else {

$category = trim($request\[0\]);
$keywords = trim($request\[1\]);

}

Kategorie und Keyword werden nun schlicht an die Amazon-API übergeben. Damit ich auch Vorschaubilder erhalte, muss ich das in der Suche explizit angeben. Die Anfrage an die API sieht nun also so aus:

$search = new Search(); $search->setCategory($category); $search->setKeywords($keywords); $search->setResponseGroup( array( ‘Images’, ‘ItemAttributes’ ) ); $search->setPage(1);

Das ganze wird nun in ein Objekt gepackt und in einer Schleife durchlaufen um die Antwort für den Bot zu erzeugen. Das hat sich bei den ersten Versuchen als schwierig erwiesen. Es hat eine Weile gedauert, bis ich herausgefunden habe, dass ich die Eigenschaften des Antwort-Objekts als String casten muss: (string)!

foreach ($this->apiResult->Items->Item as $item) {

$title = (string) $item->ItemAttributes->Title; $url = (string) $item->DetailPageURL; $thumbFileUrl = (string) $item->LargeImage->URL; $thumbFileName = basename($thumbFileUrl); $thumbFileType = pathinfo($thumbFileName, PATHINFO_EXTENSION);

if ($thumbFileType == ‘jpg’ || $thumbFileType == ‘jepg’) {

$this->inlineQueryResult\[\] = new InlineQueryResultPhoto(
array(
		'id'                    => sizeof($this->inlineQueryResult),
		'title'                 => $title,
		'description'           => $title,
		'caption'          		=> $title@,
		'thumb\_url'             => $thumbFileUrl,
		'photo\_url'             => $thumbFileUrl,
		'input\_message\_content' => new InputTextMessageContent(\[
			'parse\_mode' => 'HTML',
			'message\_text' => ' ' . 'Shop it @ <a href="'.$url.'">Amazon</a>!'\])
	)
);

}

if (sizeof($this->inlineQueryResult) >= $this->limitResult) {

break;

}

}

Grundsätzlich war es das. Das ganze Script gibt es zum Nachlesen wie gesagt auf github.

Zugriffsstatistiken mit Botan aufzeichnen und darstellen

Um Botan nutzen zu können, brauchst du einen Account bei AppMetrica von Yandex. Dort kannst du direkt nach der Registrierung einen API-Schlüssel für deinen Bot anlegen:

[caption id=“attachment_1649” align=“aligncenter” width=“300”] AppMetrics API Key für Bot anlegen[/caption]

Wenn das erledigt ist, gelangst du zu der Übersichtsseite deines Bots und siehst dort den API-Key, den du als token in der manager.php einträgst. Die entsprechenden Zeilen müssen natürlich auch auskommentiert werden:

    // Botan.io integration
    'botan' => \[
       'token' => '123123123-123123123-123123',
    \],

Das ist es schon fast gewesen. Wenn da nicht der Datenschutz wäre. Wenn du Telegramm-Bot im Chat nun “anrufst”, erscheint der Aufruf einige Augenblicke später auch im Interface von AppMetrics. Allerdings sind dann auch eine UserId und der Vorname im Klartext enthalten. Um das zu vermeiden, musst du Methode track in der Botan-Klasse (Botan.php in vendor\longman\telegram-bot\src\) anpassen:

Direkt an den Anfang der Methode habe ich die folgende Anonymisierung eingefügt:

// ANONYMIZING STATS if (isset($update->inline_query)) {

if (isset($update->inline\_query\['from'\])) {

	if (isset($update->inline\_query\['from'\]\['id'\])) {
	
		$update->inline\_query\['from'\]\['id'\] = '0';
		$update->inline\_query\['from'\]\['first\_name'\] = 'anon';
		$update->raw\_data\['inline\_query'\]\['from'\]\['id'\] = '0';
		$update->raw\_data\['inline\_query'\]\['from'\]\['first\_name'\] = 'anon';
			
	}
}

}

Weiter unten wird eine UserId ($uid) ermittelt. Auch hier habe ich anonymisiert:

// In case there is no from field assign id = 0 // $uid = isset($data[‘from’][‘id’]) ? $data[‘from’][‘id’] : 0; // ANONYMIZING STATS $uid = 0;

Jetzt dürften keine Klarnamen mehr übermittelt werden und der Bot ist startklar.

Viel Spass mit deinem Telegramm-Bot.

Die Aufgabe lautet also: Ein Script soll in regelmäßigen Abständen Test-Dateien herunterladen. Die Dauer dafür und der Zeitpunkt des Tests schreibe ich in eine CSV-Datei, die mit GoogleDrive synchronisiert ist. Von dort werden die Ergebnisse im DataStudio von Google automatisch ausgelesen.

Schritt 1 - das automatisierte Download-Script

Damit der Test möglichst unterschiedliche Szenarien abdeckt, wollte ich nicht nur eine sondern mehrere Dateien verschiedener Größe anbieten. Dazu habe ich auf http://speedtest.ftp.otenet.gr zurückgegriffen. Dort werden verschiedene Dateigrößen zum Download angeboten.

Außerdem will ich jede Datei mehr als ein mal herunterladen und schließlich nach jedem Download eine Pause einlegen.

Die Hauptfunktionen möchte ich kurz erläutern:

• In den ersten beiden Schleife wird jeder Eintrag aus sourceFileSizes einmal durchlaufen und zwar so oft, wie mit loops festgelegt:

for sourceFileSize in “${sourceFileSizes[@]}”; do while [ $i -lt $loops ]; do … done done

• Innerhalb der Schleife wird im Grund nur die Test-Datei per wget an einen definierten Ort heruntergeladen. Außerdem soll natürlich die Dauer dafür gemessen werden. Das funktioniert ganz einfach und extrem präzise in Nanosekunden bzw. über den Unix-Timestamp.

startTime=$(($(date +%s%N)))

wget –quiet –output-document=$destinationFolder$sourceFileSize"Mb.db.tmp" $sourceBaseUrl$sourceFileSize"Mb.db"

endTime=$(($(date +%s%N)))

delayNsecs=$(($endTime - $startTime))

• Die Berechnung der Geschwindigkeit ist etwas kompliziert, da ich auf der Shell nicht ohne weiteres Dezimalzahlen (float numbers) verarbeiten kann. Ich muss also mit awk arbeiten. Awk hingegen greift nicht auf die lokalen Variablen zu. Diese muss ich mit dem Parameter -v erst explizit übergeben. Am Ende entstehen dann Zeile wie diese, die im Grunde nur MByte in MBit umrechnen (mit 8 multiplizieren) und dann durch die Dauer in Sekunden dividieren. Das Ergebnis ist dann die Geschwindigkeit MBit/Sekunde - und damit perfekt vergleichbar mit der versprochenen Geschwindigkeit des Anbieters.

MBitPerSec= $(awk -v sourceFileSize=$sourceFileSize -v delayMSecs=$delaySecs ‘BEGIN{printf “%.4f\n”, ( sourceFileSize * 8 / delayMSecs)}’)

• Schließlich wird der ganze Spaß natürlich noch in die CSV-Datei geschrieben:

echo “$(date ‘+%Y-%m-%d %H:%M:%S’), $delayNsecs, $delaySecs, $MBitPerSec, $sourceFileSize"MByte”" » $journalFile

• Am Ende wird entweder das Script verlassen, wenn zuletzt die 1GByte-Datei heruntergeladen wurde. Da das Script mehrmals am Tag läuft, will ich das Volumen nicht unnötig strapazieren. Oder es wird eine definierte Pause eingelegt, damit sich die Leitung abkühlen kann.

Das komplette Script gibt es auf  github.

Das ganze muss nun nur in der CronTabelle des Systems regelmäßig aufgerufen werden. Der Zielordner

/share/Download/Speedtest/

wird außerdem mit GoogleDrive synchronisiert.

Die fertige Datei besitzt fünf Spalten, die den Zeitpunkt, die Dauer und die heruntergeladene Datei beinhalten:

column1,column2,column3,column4,column5 2017-10-31 11:48:36,1072562724,1.072562724,7.45877124105611,1MByte 2017-10-31 11:48:37,899356112,0.899356112,8.89525282950432,1MByte 2017-10-31 11:48:38,1002897956,1.002897956,7.97688334305469,1MByte

Anmerkung: Ich nutze den Netzwerkspeicher von QNAP, das TS-431. Für diesen wird ein Backup & Sync-Plugin angeboten, das lokale Ordner mit einem Ordner in GoogleDrive synchronisiert.

Schritt 2 - der Community Connector für das DataStudio

Das Google DataStudio bringt von Hause aus schon eine Reihe von Schnittstellen mit, über die es möglich ist, auf z.B. Datenbanken oder Online-Dienste zurückzugreifen um in Echzeit an allerlei Messreihen zu kommen. Doch leider fehlt hier bisher ein Verbindung zu CSV-Dateien. Den Connector musste ich mir also erst selber erstellen.

Der Connector ist im Moment noch sehr einfach gehalten. Es ermöglicht keine großen Anpassungen und ist sicherlich noch verbesserungsfähig ( Link zum Connector ):

function getConfig() { var config = { configParams: [ { type: “INFO”, name: “csvConnector”, text: “The CSV-Connector currently supports a fixed amount of three columns. Name them column1, column2 and column3. Column1 is the dimension, column2 holds the metrics and column3 may be used as an additional category. You may change the label in the next window.” } ,{ type: “TEXTINPUT”, name: “url”, helpText: “If you want to use a CSV-file from GoogleDrive, use this format where 123 at the end is your document id: https://drive.google.com/uc?export=download&id=123" , displayName: “Provide the url to your csv file.” }

\]

}; return config;

};

var csvDataSchema = [ { name: ‘column1’, label: ‘column1’, dataType: ‘STRING’, semantics: { conceptType: ‘DIMENSION’ } }, { name: ‘column2’, label: ‘column2’, dataType: ‘NUMBER’, semantics: { “isReaggregatable”: true, conceptType: ‘METRIC’ } },{ name: ‘column3’, label: ‘column3’, dataType: ‘STRING’, semantics: { “isReaggregatable”: false, conceptType: ‘DIMENSION’ }

} ];

function getSchema(request) {

return {schema: csvDataSchema};

};

function isAdminUser() { return true; }

function csvToObject(array) {

var headers = array[0];

var jsonData = []; for ( var i = 1, length = array.length; i < length; i++ ) { var row = array[i]; var data = {}; for ( var x = 0; x < row.length; x++ ) { data[headers[x]] = row[x]; } jsonData.push(data);

}

return jsonData;

} /* function stringToObject(string, separator) { var object = {};

var array = string.split(separator);

for (var i = 0; i < array.length; i++) {

if (i % 2 === 0) { 

  object\[array\[i\]\] = array\[i + 1\];

} else { 

  continue;
  
}

}

return object } */

function getData(request) {

/* I DONT GET SPLIT TO WORK SO FOR NOW THIS ONLY SUPPORTS PREPARED AND WORKING SHARING URL FOR GOOGLE DRIVE if (request.configParams.isGoogleDrive == “true”) { var urlString = request.configParams.url.toString();

var urlArray = urlString.split("?");

  var params = stringToObject(urlArray, '"');

  var docId = params\["id"\];

  var url = "https://drive.google.com/uc?export=download&id=" + docId;

} else {

  var url = request.configParams.url;

} */

var url = request.configParams.url;

var dataSchema = [];

request.fields.forEach(function(field) { for (var i = 0; i < csvDataSchema.length; i++) { if (csvDataSchema[i].name === field.name) { dataSchema.push(csvDataSchema[i]); break; } } });

var csvFile = UrlFetchApp.fetch(url);

var csvData = Utilities.parseCsv(csvFile);

var sourceData = csvToObject(csvData);

var data = [];

sourceData.forEach(function(row) { var values = []; dataSchema.forEach(function(field) { switch(field.name) { case ‘column1’: values.push(row.column1); break; case ‘column2’: values.push(row.column2); break; case ‘column3’: values.push(row.column3); break; default: values.push(’’); } }); data.push({ values: values }); });

return { schema: dataSchema, rows: data };

};

function getAuthType() { var response = { “type”: “NONE” }; return response; }

Leider unterstützt der Connector bisher nur drei Spalten mit vorgegebene Spalten-Namen. In einer nächsten Version sollte der Connector die Datei bereits im Vorfeld auslesen um die Spalten-Konfiguration selber zu erkennen.

Schritt 3 - Darstellung im DataStudio

Im Data Studio ein Diagramm erstellen, dass die Messwerte der regelmäßigen Test-Download darstellt: Darum muss ich mich noch kümmern.

Links und noch  mehr Links

Link zu GitHub mit dem Quellcode

Link zum Connector

Einführung und Doku auf developers.google.com

kleinere Beispiele auf benlcollins.com

andere Projekte auf github.com

Das System ist OS 10.12.6 und ich nutze das XAMPP-Paket 7.1.9 mit entsprechend PHP 7.1. Außerdem habe ich mir homebrew installiert, da die Installation von pecl zu Umständlich (ich hätte alle möglichen  Abhängigkeiten installieren müssen). Mit homebrew habe ich mir also den aktuellen mongodb-Treiber installiert, das geht recht einfach mit:

brew update brew install php71-mongodb

Danach lässt sich die Extension in der /Applications/XAMPP/xamppfiles/etc/php.ini Datei aktivieren:

extension="/usr/local/opt/php71-mongodb/mongodb.so"

Soweit. So einfach. Das Problem: Nachdem ich diese Zeile in der php.ini Datei hinzugefügt hatte, ließ sich der Apache-Dienst nicht mehr über die XAMPP-Oberfläche starten, obwohl diese mit root-Rechten ausgeführt wird. Leider gab auch die Log-Datei /Applications/XAMPP/xamppfiles/logs/error_log nicht viel her. Und auch nachdem ich die Zeile aus der php.ini-Datei entfernt habe, trat das Problem weiter auf. Ich bekam den Web-Server also nicht zum laufen und an keiner Stelle in den Log-Dateien war ersichtlich, was nicht stimmte.

[caption id=“attachment_1567” align=“aligncenter” width=“300”] XAMPP UI in OS X um den Web-Server zu starten[/caption]

Recherche der aufgerufenen Kommandos

Also musste ich mich auf die Fehlersuche machen. Und das ist recht umständlich, denn der Klick auf den Button im XAMPP-UI stößt eine etwas längere Befehlskette an deren Ende der Start des http-Daemons steht:

1/Applications/XAMPP/xamppfiles/ctlscript.sh start apache
2-> 
3/Applications/XAMPP/xamppfiles/apache2/scripts/ctl.sh start
4->
5/Applications/XAMPP/xamppfiles/xampp startapache 
6-> 
7/Applications/XAMPP/xamppfiles/bin/apachectl -k start -E /Applications/XAMPP/xamppfiles/logs/error_log -DSSL -DPHP
8->
9/Applications/XAMPP/xamppfiles/bin/httpd -k start -E /Applications/XAMPP/xamppfiles/logs/error_log -DSSL -DPHP

Ich hab mir also den letzten Aufruf geschnappt und auf der Konsole ausgeführt. Dort erhielt ich den ersten entscheidenen Hinweis - die log-Dateien waren nicht schreibbar:

(13)Permission denied: AH00086: httpd: could not open error log file /Applications/XAMPP/xamppfiles/logs/error_log. AH00548: NameVirtualHost has no effect and will be removed in the next release /Applications/XAMPP/xamppfiles/etc/extra/httpd-vhosts.conf:40 (13)Permission denied: AH00072: make_sock: could not bind to address [::]:80 (13)Permission denied: AH00072: make_sock: could not bind to address 0.0.0.0:80 no listening sockets available, shutting down

Das lässt sich schnell mit folgendem Aufruf beheben:

sudo chmod a+w /Applications/XAMPP/xamppfiles/logs/error_log

Damit war es natürlich noch nicht getan. Erst jetzt konnte ich dem error.log entnehmen, was das eigentliche Problem war:

AH00548: NameVirtualHost has no effect and will be removed in the next release /Applications/XAMPP/xamppfiles/etc/extra/httpd-vhosts.conf:40 (13)Permission denied: AH00072: make_sock: could not bind to address [::]:80 (13)Permission denied: AH00072: make_sock: could not bind to address 0.0.0.0:80 no listening sockets available, shutting down AH00015: Unable to open logs

Lösung - fehlende Rechte

Im Grunde war ja schon klar, was getan werden musste: Der Aufruf mit sudo. Damit lässt sich der Apache-Dienst also zumindest erstmal starten:

sudo /Applications/XAMPP/xamppfiles/bin/httpd -k start -E /Applications/XAMPP/xamppfiles/logs/error_log -DSSL -DPHP

Das eigentliche Problem bleibt freilich bestehen: Was hat das mit der php-Extension zu tun? Liegt es an dem mongodb-Treiber selber oder ist es ein generelles Problem? Bisher bin ich noch nicht dahinter gestiegen. Aber zumindest lässt sich der Web-Server erstmal wieder starten.

Die CFW aktiviert zugleich den Telnet-Server, über den ab sofort die nächsten Schritte durchgeführt werden. Praktischerweise hat OSX (als Linux-Derivat) einen SSL-Telnet-Server eingebaut… also das MacBook von Windows zurück in OSX booten.

2. Schritt: Den Paketmanager IPKG installieren - das geschieht nach folgender Anleitung über Telnet: http://buffalo.nas-central.org/wiki/Category:LS-WXL#IPKG

3. Schritt: Den MiniDLNA-Server installieren und dabei folgende Schritte durchgehen: http://forum.nas-hilfe.de/buffalo-technology-nas-anleitungen/minidlna-ab-version-1-0-22-from-scratch-kompilieren-installieren-t1130.html

4. Dabei wird es voraussichtlich - bzw. ob der “Aktualität” der Anleitung mit ziemlicher Sicherheit - zu einem Fehler kommen: GetText ist zu alt. Dann hilft folgendes:

cd /usr/share/doc/ (Anm.: Diesen Ordner musste ich erst anlegen, ggf. nachholen)

wget -0 gettext.tgz  http://ftp.gnu.org/pub/gnu/gettext/gettext-0.18.2.tar.gz

tar xvzf gettext.tgz

danach entsprechend dieser Anleitung:

./configure - das dauert eine kleine Ewigkeit, da kann man schon mal n Kaffee trinken gehen

make check

make install

make clean

Tipps: Ab einem Punkt der Anleitung lautet es “Jetzt das in das Verzeichnis des miniDLNA wechseln und einfach”. Wo das liegt? Gute Frage. Ich musste erst suchen und bin unter /usr/sbin/minidlna fündig geworden - von dort aus klappt dann auch der autoconf-Befehl.

Fertig. Für Live-Transcoding dürfte die WXL mit knapp 600 MHz-Prozessor etwas schwach sein, aber dafür läuft der Medienserver um einiges fixer und sieht dabei auch schöner aus (wenn man über die PS3 browsed), als der mitgelieferte Twonky.

Mehr dazu:

linux-forum.de

nas-hilfe.de

In dieser kleinen Tutorial-Serie will ich anhand einer Online-Handy-Datenbank zeigen, wie man mit VBA Seiten aus dem Internet abruft und nach Informationen sucht, die sich dann in einer Tabelle abspeichern lassen. Warum VBA? Es gibt vermutlich elegantere Lösungen, doch Excel ist eine Software, die meisten zuhause nutzen. Man benötigt also keine zusätzliche Entwicklungsumgebung. Außerdem hat diese Methode den Vorteil, dass die Daten sofort zur weiteren Verarbeitung verfügbar sind. VBA ist vielleicht nicht die performanteste Programmiersprache, dafür aber relativ leicht zu beherrschen.

(FYI: Rechtliches zum Thema Web- oder Screen-Scraping)

Diese Artikelserie richtet sich an den fortgeschrittenen Nutzer. Für den Einsteiger gehe ich nicht auf grundlegendes Programmierwissen ein (was sind Klassen, welche Variablen-Typen bietet Excel, etc.) und für den professionellen Softwareentwickler sind meine Codebeispiele vermutlich zu einfach. Ich habe aber die Erfahrung gemacht, dass VBA und Excel für kurzfristige und kleine Projekte dieser Art recht nützliche Hilfsmittel sind. Außerdem bin ich kein “ausgebildeter Softwareentwickler”, weshalb ich an der Stelle auch gleich darauf hinweise, dass Verbesserungsvorschläge sehr gerne gesehen sind!

Welches Wissen solltest du also mitbringen? Da es um das Parsen von HTML-Code geht, solltest du zumindest Bescheid wissen, wenn ich von div- und a-Elementen und CSS-Klassen rede. Du solltest auch wissen, wie man in VBA Variablen deklariert oder was eine if-Abfrage ist.

Das Endergebnis ist eine Tabelle mit technischen Spezifikationen zu den Mobiltelefonen, die inside-handy.de listet. Insgesamt werden drei Routinen genutzt, die - in umgekehrter Reihenfolge des Vorgehens - folgende Aufgaben haben:

1. Die letzte Routine greift auf eine Liste von URLs zu, die auf die Datenblätter der Geräte verweisen. Von dort wird der HTML-Quellcode nach den technischen Informationen durchsucht.
2. Auf inside-handy.de sind die Geräte nach Herstellern sortiert. Jede Herstellerseite verweist auf die entsprechenden Geräte. Wir werden also jede Herstellerseite (bzw. den entsprechenden HTML-Code) zunächst nach den URLs zu den Geräten durchsuchen. Diese Aufgabe übernimmt die zweite Routine bzw. Prozedur.
3. Die erste Routine schließlich liefert die Liste aller URLs zu den Herstellern, die wir uns aus dem HTML-Code der Herstellerübersicht auf inside-handy.de laden.

Und damit geht es nun los:

1. Die URL zu den Hersteller-Unterseiten auslesen - sub getManufacturer

1.1 Datei per HTTP von einem Server laden

Im ersten Schritt laden wir die komplette HTML-Datei in den Zwischenspeicher. Dazu gibt es mindestens zwei Methoden, die gängigste ist vermutlich die über WinHttpRequest . Bevor du das nutzen kannst, musst du bei VBA unter Extras → Verweise die Microsoft HTML Object Library einbinden.

1Dim url As String
2Dim result As String
3Dim winHttpReq As Object
4url = "http://www.inside-handy.de/hersteller/handys"
5
6Set winHttpReq = CreateObject("WinHttp.WinHttpRequest.5.1")
7winHttpReq.Open "GET", url, False
8winHttpReq.send
9result = winHttpReq.responseText

Die Deklaration der Variablen erklärt sich von selbst. Nachdem ich eine Instanz vom WinHTTP-Objekt erzeugt habe, kann ich die Parameter übergeben. Dazu gehört neben der URL auch die Bestimmung des HTTP-Requests - nämlich GET. Der letzte, booleansche Parameter gibt an, ob die Verbindung im asynchronen Modus geöffnet werden soll. Mit .send wird der Request tatsächlich ausgelöst und das Ergebnis dann an die String-Variable result zurückgegeben. Dort befindet sich nun unser HTML-Code.

Wir können unseren Request natürlich auch per POST absetzen und noch andere Header-Informationen anhängen:

1Set winHttpReq = CreateObject("WinHttp.WinHttpRequest.5.1")
2
3winHttpReq.Open = "Post", url, False
4winHttpReq.setRequestHeader "User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)"
5winHttpReq.setRequestHeader "Content-type", "application/x-www-form-urlencoded"
6winHttpReq.send (URLEncode("username=user1&password=secret"))
7
8result = winHttpReq.responseText

So ist es z. B. möglich, Formulardaten zu übermitteln, um an eine passwortgeschützte Seite oder die Ergebnisseite einer Suche zu gelangen. Dabei werden die POST-Daten als weiterer Parameter beim Senden mitgegeben. Eine weitere Möglichkeit ist die Durchführung einer HTTP-Authentifizierung:

1Dim HTTPREQUEST_SETCREDENTIALS_FOR_SERVER As Boolean
2
3winHttpReq.Open "GET", url, False
4winHttpReq.SetCredentials "user", "password", HTTPREQUEST_SETCREDENTIALS_FOR_SERVER
5winHttpReq.send

Neben dem winHttpRequest-Objekt gibt es noch eine weniger elegante Methode, in der direkt eine Instanz des Internet Explorers erzeugt wird:

 1Dim sPostData As String
 2Dim bPostData() As Byte
 3Dim WebBrowser: Set WebBrowser = CreateObject("InternetExplorer.Application")
 4
 5WebBrowser.Visible = True
 6
 7sPostData = URLEncode("username=user1&password=secret")
 8ReDim bPostData(Len(sPostData) - 1)
 9bPostData = StrConv(sPostData, vbFromUnicode)
10
11WebBrowser.navigate url, 2 + 4 + 8, , bPostData, "Content-type: application/x-www-form-urlencoded"
12Do While WebBrowser.Busy
13    DoEvents
14Loop
15result = WebBrowser.document.body.innerHTML 
16WebBrowser.Quit

Da diese Methode - wie gesagt - nicht sonderlich elegant ist, werde ich aber nicht weiter darauf eingehen.

HTML-Dokument erzeugen und befüllen

Nun zurück zu unserem Skript. Den HTML-Code der Seite haben wir nun erstmal in einen String gelegt. Damit wir das HTML-Dokument bequem lesen können, erzeugen wir ein HTML-Document, an das wir den HTML-Code übergeben:

1Set HTMLDoc = New HTMLDocument
2Set HTMLDoc = CreateObject("htmlfile")
3HTMLDoc.Open
4HTMLDoc.write (CStr(result))
5HTMLDoc.Close

Auch hier erklärt sich der Code fast von selbst: Eine Instanz des Objektes erzeugen, diese Instanz zum “Befüllen” vorbereiten, den String übergeben und die Instanz wieder “schließen”. Soweit, so unkompliziert. Im nächsten Schritt geht es nun direkt an das Parsen des Quellcodes, um die Links zu den Herstellerseiten zu erhalten.

Schleife zum Auslesen der Links

 1Dim oneElement1, allElements1 As IHTMLElementCollection
 2Dim oneElement2, allElements2 As IHTMLElementCollection
 3Dim oneElement3, allElements3 As IHTMLElementCollection
 4
 5Worksheets("srcURL").Range("a2").Select
 6i = 0
 7Set allElements1 = HTMLDoc.getElementsByTagName("a")
 8      
 9i = 0
10For Each oneElement1 In allElements1
11    If oneElement1.parentElement.className = "h_img" Then
12        If oneElement1.parentElement.parentElement.ID = "h_alle" Then
13            If InStr(1, oneElement1.getAttribute("href"), "/tablets") <= 0 Then
14                Selection.Offset(i, 0).Value = Replace(oneElement1.getAttribute("href"), "about:", "http://www.inside-handy.de")
15                i = i + 1
16            End If
17        End If
18    End If    
19Next oneElement1
20End Sub

Wie bin ich vorgegangen? Ich habe mir zunächst den Quellcode der Seite angeschaut. Die Liste der Hersteller ist dort eine Tabelle mit den Logos der Unternehmen. Die gewünschte Information befindet sich in a-Elementen, die wiederum innerhalb eines div-Elements liegen. Das gemeinsame “Oberelement” ist ein div-Container mit der CSS-Klasse h_img bzw. einem weiteren div-Container (h_alle). Außerdem gibt es einen ausgeblendeten div-Container mit einer Liste von Tablet-Herstellern, diese haben den Begriff "/tablet" in der href-Angabe und müssen ignoriert werden.

1<div id="h_alle">
2    <div class="h_img">
3        <a href="/hersteller/xyz" title="Handys Hersteller: XYZ">
4            <img />
5        </a>
6    </div>
7</div>

Mit Set allElements1 = HTMLDoc.getElementsByTagName("a") lasse ich mir also erst alle a-Elemente aus dem Quellcode in meinen “Container” legen.

Mit der ersten for-each-Schleife durchlaufe ich nun diesen Container und prüfe mit den ersten zwei if-Abfragen, ob sich das a-Element unterhalb der erwähnten div-Container befindet. Da auf der Seite noch ein weiterer identischer div-Container mit diesen CSS-Klassen für die Liste der Tablet-Hersteller existiert, muss ich mit einer dritten if-Abfrage die URL des a-Elements überprüfen. Erst dann kann ich das Attribut des a-Elements auslesen und in mein Excel-Worksheet schreiben.

Fertig ist der erste Schritt - eine Liste der URLs zu den jeweiligen Herstellern. Im nächsten Teil werde ich diese Liste durchgehen und von den jeweiligen Seiten die URLs zu den Geräten auslesen.