Contao Konferenz 2019
Gemeinsam
an Contao-Projekten arbeiten
Gemeinsam an Contao Projekten arbeiten
Arbeiten mehrere Entwickler gleichzeitig an einer Contao-Instanz, behindern sie sich oft gegenseitig.
Arbeitet jeder auf einer eigenen Instanz, gibt es häufig Probleme beim Synchronisieren. Wie arbeitet man am
besten mit Tools wie z.B. git und gitlab? Und wie hält man die Datenbank konsistent? Hier gibt der Vortrag
Einblicke in die Arbeit bei trilobit, die auch als Denkanstöße oder Best Practices für andere dienen können.
Wer bin ich? trilobit GmbH
In eigener Sache
Wer bin ich / trilobit GmbH
Peter Adelmann
seit 2002 bei trilobit
12 Mitarbeiter (letztes Jahr noch 8!)
Contao-Premium-Partner für WebDesign, Programmierung und Schulung
eine von 5 Agenturen mit Triple-Premium-Partner
Mit-Veranstalter des Contao-Agenturtags
Ausbildung (IHK und Berufsakademie)
Herausforderungen,
Probleme,
Vorüberlegungen
Wie werden Daten in Contao organisiert?
alle Inhalte in der Datenbank; ...
aber auch Modulkonfigurationen;
z.T. Systemkonfigurationen (z.B. Bildeinstellungen)
alle Ressourcen (Bilder, Downloads, ...) im files-Ordner auch in der Datenbank referenziert.
Konfiguration über parameters.yml , config.yml und .env Dateien
Themenbereiche
Optik / Layout
Templates
ggf. Inhalte
Funktionalitäten Core / Erweiterungen / Bundles; z.B.
Mitglieder erweitern
News / Events erweitern
individuelle Funktionalitäten / Business Logik
Projekt-Team
„Einzelkämpfer“
größeres (>= 2) Projekt-Team
Arbeitsweise
Finalisieren
verschiedene Inhalte zusammenführen; mergen
⇒ als „Einzelkämpfer“, welcher vielleicht auch seriell arbeitet, einfacher ;-)
Deployment
⇒ fällt weg, wenn direkt auf dem Zielsystem gearbeitet wurde
Weiterentwicklung
Optik, Inhalte, Layout
Funktionalitäten
BUG-Fixe, ...
(unsere) Ziele
Ziele
schneller Projekte in besserer Qualität abschließen ★★★
Team besser auslasten
individuelle Stärken besser nutzen
Code-Qualität steigern
einheitliche (Code- und Arbeitsweise-) Basis
relativ schnelles Einfinden in „Fremd-“ Projekte
paralleles Arbeiten; nicht Seriell
(unser) Weg
Analyse
Analyse
was ist uns wichtig?
was muss / soll(t)e vereinheitlicht werden?
wie greifen die verschiedenen Arbeiten ineinander?
wie können die verschiedenen Arbeiten sauber von einander getrennt werden?
wie können unsere Ziele und Wünsche erreicht werden?
Werkzeuge, Umgebung
Werkzeuge
Git
trilobit Skeleton (t)
einfacher Installationsweg (t)
GitLab
(DB-) Tools / (DB-) Commands (t)
diverse Code-Quality-Tools
php-cs-fixer
phpstan
webpack
Konventionen
Einheitliches Deployment
(t) trilobit Tools
(Entwicklungs-) Umgebung
bei allen Mitarbeitenden (nahezu) identisch
Datenbank-Konfiguration überall gleich
lokaler / eigener interner Mailserver
PHP überall gleich
einheitliche Ablage innerhalb eines Projektes einheitliche Dateisystem Struktur
Serverumgebung möglichst nah am Zielsystem
Arbeitsweisen
Arbeitsweisen
rein lokale Entwicklung
Optik / Layout
Templates
ggf. Inhalte
Funktionalitäten Core / Erweiterungen / Bundles
individuelle Funktionalitäten
im Dev-Modus ;-)
Versionierung
In der Praxis
Entwicklungs-„Server“
lokaler Webserver
lokaler MySQL-Server
lokaler Host; jedoch Haus intern überall erreichbar über eigenen DNS-Server z.B. PROJEKT.peter.dev.lokal
Arbeiten
Aufgabenverteilung nach Themengebiet
ggf. abhängigen Bereichen
nach individuellen Stärken und
Auslastung
In der Praxis
Install-Script sorgt für einheitlichen Start
alles Git versioniert
vorkonfiguriertes Skeleton
composer.json
webpack / encore
mage
minimale DB
git
eigene GitLab Instanz
alle Teilaufgaben als eigenständige feature-Branches
mit anschließendem merge Requests
Code Review
ggf. interne Feedbackrunde
ein Maintainer
master-Branch ist geschützt
teilweise IDE-Konfiguration (PhpStorm) des Projekts versioniert
Projekt initialisieren
Projekt initialisieren
neues Projekt auf GitLab anlegen
Skeleton lokal auschecken
Projekt lokal initialisieren (Referenzen auf das Skeleton-Repo werden entfernt)
Projekt lokal installieren
initialer commit ins Projekt-Repository auf GitLab
Shell
Einzelschritte zum Projektstart:
cd /var/www/html/contao
git clone git@gitlab.trilobit.de:trilobit/skeletons/c4-app-skeleton.git ck2019
cd ck2019
cp www/app/config/parameters.yml.dist www/app/config/parameters.yml
nano www/app/config/parameters.yml
./initialize-new-application-project
./install
Host einrichten und starten ;-)
Initialisierungs-Script
Git-Verlauf entfernen und vom ursprünglichen Sekeleton-Projekt lösen.
#!/usr/bin/env bash
SCRIPT_PATH="$( cd "$(dirname "$0")" ; pwd -P )"
cd ${SCRIPT_PATH}
# re-init git
echo "Reinitializing git history"
rm -rf .git
rm -rf database/tools
git init
# re-add submodules
git submodule add git@gitlab.trilobit.lokal:trilobit/tools/contao-database-tools.git database/tools
# remove this script
echo "Removing script"
rm -- "$0"
Install-Script
Verschiedene Prüfungen und Installation (composer install, yarn).
#!/usr/bin/env bash
SCRIPT_PATH="$( cd "$(dirname "$0")" ; pwd -P )"
PROJECT_ROOT="$SCRIPT_PATH/www"
check_parameters_set() {
if [[ ! -f ${PROJECT_ROOT}/app/config/parameters.yml ]]; then
echo "Please create a 'www/app/config/parameters.yml' file first."
echo "Use the content of 'www/app/config/parameters.yml.dist' and adjust to your needs."
echo "Aborting."
exit 1
fi
}
check_php_installed() {
if ! hash php7.3 2>/dev/null; then
echo "php7.3 not found."
echo "Aborting."
exit 1
fi
}
install_yarn() {
if hash yarn 2>/dev/null; then
return
fi
echo "yarn not found, installing now"
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt-get update && sudo apt-get install yarn
}
install_application() {
cd ${PROJECT_ROOT}
# composer
php7.3 composer.phar install
# assets
yarn install
yarn encore dev
echo "--------------------------------------------------------------------------------------------------"
echo "Installation completed."
echo "Run 'tools:db:import' to import the project dumps to your database."
}
# check prerequisites
check_parameters_set
check_php_installed
install_yarn
# install application
install_application
Deployment
via mage
einheitliche Konfiguration
full-deployment
(es wird gemäß Strategie / Environments immer „alles“ deployed)
Strategie / Environments
(stage, stage_complete, stage_db, stage_files, ...)
einheitliche excludes
mehrere Releases möglich
automatisches aktivieren und deaktivieren des Wartungsmodus
Helfer
Code
vendor/bin/php-cs-fixer fix
run all
Assets
dev build: yarn encore dev
production build: yarn encore production
dev build mit watcher: yarn encore dev --watch
dev-server mit hot module replacement: yarn encore dev-server --hot
Organisation
Projektleiter
Maintainer für Projekt auf GitLab
Alles, was in den Master gemerged wird, ist reviewed und prinzipiell deploybar
Milestones
Einzel-Issues (GitLab / Jira)
Besonderheiten
Allgemein
Die folgenden Punkte / Teilbereiche können „sauber“ voneinander
abgetrennt,
versioniert und
gemerged werden:
CSS, Templates, Ressourcen (Bilder, Downloads, JS Plugins, ...)
eigene Bundles und Anpassungen
Datenbank
Oft gehören auch diverse Tabellen zu eigenen Bundles und Anpassungen.
DB-Tools / DB-Commands
dumpen alle Tabellen einzeln; verschiedene Excludes
tl_user
tl_cron
tl_search , tl_search_index
tl_undo , tl_version , tl_log
diese lassen sich gezielt versionieren
und mergen
review ist hier zugegebenermaßen etwas aufwändiger ;-(
Weitere Schritte
Weitere Schritte
File-Sync
CD (Continuous Deployment ), CI (Continuous Integration )
Tests
weitere Vereinheitlichung von Strukturen und Arbeitstechniken über Projektgrenzen hinweg; z.B.
SCSS, TypeScript
Ablage
Konfigrationen
Code-Style
Docker
Symfony binary
Vielen DANK!
Wir lieben Kunden, für die der
Livegang einer Webseite
nicht das Ende
sondern der Anfang des Abenteuers ist.
trilobit GmbH
KnowHow
trilobit GmbH / Peter Adelmann
CD
Continuous Deployment
bezeichnet eine Sammlung von Techniken, Prozessen und Werkzeugen, die den Softwareauslieferungsprozess
(englisch: Deployment) verbessern. ... Diese Versionen können mit Hilfe von CD automatisiert auf
Entwicklungs-, Test-, Integrations- und Produktivumgebung eingespielt werden.
CI
Continuous Integration
Kontinuierliche Integration (auch fortlaufende oder permanente Integration; englisch continuous
integration) ist ein Begriff aus der Software-Entwicklung, der den Prozess des fortlaufenden
Zusammenfügens von Komponenten zu einer Anwendung beschreibt.
Code Quality
Softwarequalität
Unter Softwarequalität versteht man die Gesamtheit der Merkmale und Merkmalswerte eines
Softwareprodukts, die sich auf dessen Eignung beziehen, festgelegte oder vorausgesetzte Erfordernisse zu
erfüllen.