KategorieCMS

Sulu Sitemap mit Symfony Routen erweitern

Sulu ist ein Content-Management-System, welches mit Hilfe des PHP-Frameworks Symfony erstellt wurde. Das Augenmerk bei Sulu liegt in der leichten Bedienbarkeit für den Entwickler.
Wer oft mit Symfony arbeitet wird merken, wie schnell sich das System an die eigenen Anforderungen anpassen lässt. Dazu müssen keine komplexen Plugins geschrieben werden. Es greifen die herkömmlichen Symfony Standards.

So verhält es sich auch bei der Erstellung einer Sitemap. Sulu bietet bereits eine Schnittstelle, um die Sitemap zu generieren.
Es werden alle Seiten ausgelesen, die im Adminbereich über das CMS System angelegt wurden.

Über folgenden Command kann eine Sitemap initial generiert werden.

bin/websiteconsole sulu:website:dump-sitemap

Im Produktivsystem können Optionen mit übergeben werden, wie z.B.

bin/websiteconsole sulu:website:dump-sitemap --https --env=prod

Meine Ausgangssituation

In meinem Projekt habe ich nun den folgenden Fall:

  • Die meisten Seiten werden direkt über das Sulu CMS im Adminbereich erstellt (z.B. Rezept-Seiten). Es dient als typischer Blog. Das Template ist pro Seitentyp fest definiert.
  • Es gibt jedoch auch Seiten, die direkt in Symfony gepflegt werden, da sie separate Templates oder eine spezielle Logik im Controller besitzen.

Diese Seiten werden standardmäßig in Symfony über die routes.yaml definiert. In Sulu erfolgt dieses unter der Datei routes_websites.yaml.
Meine Datei sieht wie folgt aus:

# config/routes_website.yaml

impressum:
    path: /impressum
    controller: App\Controller\Website\StaticPageController::impressumAction

dataprotection:
    path: /datenschutz
    controller: App\Controller\Website\StaticPageController::dataprotectionAction

contact:
    path: /kontakt
    controller: App\Controller\Website\StaticPageController::contactAction

Diese Routen fehlen bislang in der Sitemap.
Es ist aber sehr einfach die Sulu Sitemap zu erweitern. Es benötigt lediglich 2 Schritte, wobei Schritt 1 optional ist.

Schritt 1 – Konfiguration anpassen (optional)

Ihr könnt über den Parameter sulu_website.sitemap.dump_dir steuern, wo die Sitemap Dateien abgelegt werden sollen. Ich habe hier den public Ordner gewählt.

# /config/services.yml
parameters:
    ...
    sulu_website.sitemap.dump_dir: "%kernel.project_dir%/public/sitemaps"

Schritt 2 – Eigene Provider Klasse anlegen

Als nächstes erstellt ihr eine eigene Provider Klasse.
Diese muss das Interface Sulu\Bundle\WebsiteBundle\Sitemap\SitemapProviderInterface einbinden und die nötigen Methoden implementieren.

Um meine statischen Routen auszulesen, habe ich eine neue Klasse SitemapProvider erstellt. In dem Array $routeNames liste ich die Namen meiner Routen auf, die in die Sitemap aufgenommen werden sollen (siehe Abschnitt: Meine Ausgangssituation)

Hier meine vollständige Klasse:

Das war es auch schon. Die Sitemap kann nun aufgerufen werden unter http://localhost:8080/sitemap.xml

Beim Aufruf werdet ihr sehen, dass Sulu die Sitemap in kleinere Dateien aufteilt. Hier findet ihr auch eure neu angelegte Sitemap mit dem Alias mySitemap , den ihr in der Provider Klasse definiert habt.

<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <sitemap>
        <loc>http://localhost/sitemaps/mySitemap-1.xml</loc>
    </sitemap>
    <sitemap>
        <loc>http://localhost/sitemaps/pages-1.xml</loc>
    </sitemap>
</sitemapindex>

Die Pfade zu den Locations löst Sulu automatisch auf. Darum müsst ihr euch nicht kümmern.
Wenn ihr nun z.B. http://localhost/sitemaps/mySitemap-1.xml aufruft, seht ihr eure definierten statischen Symfony Routen mit den jeweiligen Änderungswerten. Das Auslesen dieser Werte bestimmt ihr selbst in eurer Provider Klasse.

<urlset xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <url>
        <loc>http://localhost/impressum</loc>
        <lastmod>2020-06-10</lastmod>
    </url>
    <url>
        <loc>http://localhost/datenschutz</loc>
        <lastmod>2020-06-10</lastmod>
    </url>
    <url>
        <loc>http://localhost/kontakt</loc>
        <lastmod>2020-06-10</lastmod>
    </url>
</urlset>

That’s it !
Nun könnt ihr eure Sitemap verwenden … sie in die robots.txt eintragen, sie bei Google einreichen etc.

Ich hoffe dieser Blog Post ist für einige eine kleine Hilfestellung.

Viel Spaß damit und viele Grüße
Stefanie

Schnelles Pimcore Setup mit Docker

Ich experimentiere momentan mit dem Open-Source PIM/MDM Pimcore und die Erstellung und Integration von selbstgeschriebenen Plugins. Damit nicht unnötig Zeit für das Setup verschwendet wird, habe ich mir eine Dockerkonfiguration für die lokale Entwicklung angelegt, die mittels docker-compose gestartet werden kann.

Doch zunächst – Was ist Pimcore?

Pimcore ist eine Kombination aus Product-Information-Management (PIM) und Master-Data-Management (MDM). Auf deutsch bedeutet das soviel, dass Produkte zentral in einem System verwaltet werden können. Ebenfalls Stammdaten wie Mitarbeiter, Kunden, Hersteller oder Lieferanten können über Pimcore gepflegt werden.

Wer einen Online-Shop betreiben möchte, kann dieses ebenfalls mit Pimcore erledigen. Dazu gibt es die Erweiterung CoreShop, die viele Funktionalitäten abdeckt.

Was Pimcore unter anderem auszeichnet, ist die benutzerdefinierte Modellierung von Inhalten. Neben bereits vorgefertigten Inhaltstypen können eigene Datenstrukturen angelegt und definiert werden – ganz einfach in der grafischen Adminoberfläche.

Genug Intro – los geht’s mit Docker

Die zentrale Einstiegsstelle ist die docker-compose.yml Datei. Diese liegt direkt im Hauptprojektverzeichnis. Hier werden die Services defniert, die für Pimcore benötigt werden. Das sind ein Webserver (hier Nginx), eine Datenbank (hier MySQL) und PHP.

version: '3.3'

services:
    nginx:
        image: nginx:latest
        ports:
            - "8080:80"
        volumes:
            - .:/var/www/html
            - ./docker/nginx/config/site.conf:/etc/nginx/conf.d/default.conf
        links:
            - php
        networks:
            - pimcorenet

    mysql:
        image: mysql:5.7
        restart: always
        ports:
            - "3306:3306"
        command: --init-file /data/application/init.sql
        volumes:
            - ./docker/mysql_init.sql:/data/application/init.sql
            - ./data/mysql:/var/lib/mysql
            - .:/var/www/html
        environment:
            MYSQL_ROOT_PASSWORD: pimcore
            MYSQL_DATABASE: pimcore
            MYSQL_USER: pimcore
            MYSQL_PASSWORD: pimcore
        networks:
            - pimcorenet

    php:
        build: ./docker/php
        volumes:
            - .:/var/www/html
        links:
            - mysql:mysql
        depends_on:
            - mysql
        networks:
          - pimcorenet

networks:
    pimcorenet:

Für die Container Nginx und MySQL benutze ich fertige Docker Images. Diese können dann von außen über Parameter konfiguriert werden. Bei dem MySQL Image wird in dem Command eine SQL Datei aufgerufen, welche dafür sorgt, dass der User pimcore existiert.
Den kompletten Source Code findest du in meinem Repository unter: https://github.com/StefanieD/pimcore-docker-setup

Für den PHP Container nutze ich ein angepasstes Dockerfile. Dieses liegt unter ./docker/php und wird über den build Parameter in der Servicekonfiguration referenziert.

Oft reichen fertige PHP Docker Images nicht aus, da bestimmte Erweiterungen nachinstalliert werden müssen. Aus diesem Grund erweitert das Dockerfile ein existierendes Image für php7.2-fpm

FROM php:7.2-fpm

# install git
RUN apt-get update && \
    apt-get install -y --no-install-recommends git

#install some base extensions
RUN apt-get install -y \
    zlib1g-dev \
    zip \
    libpng-dev \
    exiftool \
    libfreetype6-dev \
    libjpeg62-turbo-dev \
    libmcrypt-dev \
    libicu-dev \
    libpq-dev \
    libxpm-dev \
    libvpx-dev \
    mariadb-client \
    libxml2-dev

RUN docker-php-ext-install -j$(nproc) \
    zip \
    exif \
    bcmath \
    intl \
    pcntl \
    mysqli \
    pdo \
    pdo_mysql \
    pdo_pgsql \
    mbstring \
    soap \
    opcache \
    iconv

# Install Imagick
RUN apt-get update && apt-get install -y \
    libmagickwand-dev --no-install-recommends \
    && pecl install imagick \
    && docker-php-ext-enable imagick

# Install Composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
RUN composer --version

Und zu guter Letzt – Docker starten

Um die Anwendung nun zu starten, braucht man nichts anderes tun als im Terminal zu seinem Projektordner zu wechseln und folgende Befehle auszuführen

docker-compose build 

zum Bauen der Images und

docker-compose up -d

Beim ersten Aufruf werden die Images vom Docker Repository heruntergeladen und es kann etwas länger dauern. Später sind diese jedoch im Cache und müssen nicht erneut geladen werden.

Nachdem die Container gestartet sind, müssen noch einige Befehle manuell durchgeführt werden.
Pimcore muss installiert, ein initialer Admin User angelegt und die Datenbank konfiguriert werden.
Die Anleitung dazu findest du hier https://github.com/StefanieD/pimcore-docker-setup

Nachdem diese Schritte erfolgreich durchgeführt wurden, ist die Anwendung nun unter http://localhost:8080 erreichbar.
Den Adminbereich erreicht man unter http://localhost:8080/admin.

Mit dem zuvor angelegten Benutzer admin – admin könnt ihr euch in Pimcore anmelden.

Viel Spaß beim Experimentieren !

Quellen

  • https://pimcore.com/de
  • https://blog.perfion.com/de/was-ist-der-unterschied-zwischen-pim-und-mdm-und-warum-sie-sich-interessieren-sollten
  • https://basilicom.de/de/pimcore
  • https://www.mds.eu/blog/pim/was-ist-pimcore
  • https://divante.co/blog/pimcore-special-agency-point-view/