DDEV et Magento 2

Développement local et actions GitHub

Introduction

Je souhaite ici vous parler d'un outil que j'ai découvert il y a quelques mois : DDEV.

Pour résumer, DDEV facilite la mise en place d'une stack Docker pour vos développements PHP. J'ai été surpris par la rapidité avec laquelle on pouvait le prendre en main et je l'utilise, entre autres, pour mes développements Magento 2.

Je ne parlerai pas en détail de tout ce qu'il est possible de faire avec DDEV. Il existe un grand nombre de ressources (en particulier awesome-ddev) et sa documentation me semble assez claire pour faciliter son installation et sa customisation.

Je préfère simplement partager ici mon expérience en évoquant deux types de tâches pour lesquelles DDEV m'a simplifié la vie :

• installer Magento 2 et développer des modules en local
• mettre en place des actions GitHub pour tester plusieurs versions de Magento 2 et PHP de manière automatisée.

La première étape consiste à installer tout ce qu'il faut :

Étape 1 : Installations

Installation de DDEV

Pour installer DDEV, le mieux est de suivre la documentation officielle. Sur une distribution Linux, vous pourriez certainement lancer ce type de commande :

sudo apt install linuxbrew-wrapper
brew tap drud/ddev && brew install ddev

Préparation de l'environnement DDEV pour Magento 2

Avant de commencer, notez que la structure finale de votre projet en local sera celle-ci :

m2-sources
│
│ (sources Magento 2 installées avec composer)
│
└───.ddev
│   │
│   │ (fichiers de configurations DDEV)
│
└───my-own-modules (seulement si vous souhaitez tester un module)
    │
    │
    └───yourVendorName-yourModuleName
       │
       │ (Sources d'un module)

Pour remplir le dossier .ddev ci-dessus, j'utiliserai ici des configurations DDEV spécifiques. Il s'agit en fait des configurations que DDEV génère automatiquement lorsque vous lui précisez que vous souhaitez travailler sur un projet Magento 2 auxquelles j'ai rajouté quelques fichiers et commandes DDEV. Par exemple, j'ai rajouté des fichiers docker-compose.yaml lorsque j'ai voulu travailler avec d'autres containers Docker, des fichiers de configuration Varnish, PHPSTAN ou Nginx pour certains usages bien spécifiques et j'ai créé des commandes pour simuler des crons ou lancer des scripts personnalisés.

Dans l'immédiat, vous pouvez utiliser mes sources sans chercher à comprendre dans le détail, mais l'idée est que chacun puisse faire selon ses besoins en rajoutant ses propres fichiers et commandes DDEV. Je donnerai plus bas quelques exemples plus précis de commandes que j'ai rajoutées.

Ainsi, si vous voulez voir ce que ça donne sur votre machine :

• Créez un dossier vide m2-sources :

mkdir m2-sources

• Dans ce dossier, créez un dossier caché vide .ddev et clonez mon dépôt GitHub :

mkdir m2-sources/.ddev && cd m2-sources/.ddev && git clone git@github.com:julienloizelet/ddev-m2.git ./

• Dans cet exemple, nous allons installer un Magento 2.4.3 avec PHP 7.4. Pour cela, copiez un petit fichier de configuration :

cp .ddev/config_overrides/config.m243.yaml .ddev/config.m243.yaml

• Enfin, lancez DDEV

cd .ddev && ddev start

Le premier lancement prendra pas mal de temps, car il faut télécharger les images docker. Par la suite, ce sera bien plus rapide.

Par curiosité, vous pouvez ensuite lancer un ddev describe qui vous donnera quelques informations sur les différents services Docker utilisés.

Installation de Magento 2

Pour installer Magento 2, vous aurez besoin de vos clés privées et publiques Magento 2. Elles vous seront demandées lors de l'installation avec composer.

DDEV dispose de certaines commandes de base qui permettent de lancer des commandes usuelles dans le container docker adéquat. Par exemple, ddev composer lance composer dans le container web où se trouvent les sources. Ainsi, pour installer Magento 2.4.3, vous pouvez faire :

ddev composer create --repository=https://repo.magento.com/ magento/project-community-edition:2.4.3

De même, ddev magento lance l'exécutable CLI bin/magento. Ainsi, pour terminer l'installation, lancez :

ddev magento setup:install \
--base-url=https://m243.ddev.site \
--db-host=db \
--db-name=db \
--db-user=db \
--db-password=db \
--backend-frontname=admin \
--admin-firstname=admin \
--admin-lastname=admin \
--admin-email=admin@admin.com \
--admin-user=admin \
--admin-password=admin123 \
--language=en_US \
--currency=USD \
--timezone=America/Chicago \
--use-rewrites=1 \
--elasticsearch-host=elasticsearch

Et voilà, Magento 2 est installé et fonctionnel.

Pour faciliter mes développements en local, je complète parfois avec des commandes du type :

ddev magento config:set admin/security/password_is_forced 0
ddev magento config:set admin/security/password_lifetime 0
ddev magento module:disable Magento_TwoFactorAuth
ddev magento indexer:reindex
ddev magento c:c

Ou encore, pour jouer avec des données de tests :

ddev magento setup:performance:generate-fixtures setup/performance-toolkit/profiles/ce/small.xml

Les installations sont terminées. Dans la deuxième étape, je décris comment je développe mes modules en local :

Étape 2 : Développement d'un module en local

Sources du module

Il y a plusieurs façons de développer un module en local. Le plus simple est peut-être de placer ses sources dans app/code. En ce qui me concerne, je préfère modifier le composer.json du projet pour ajouter un repository de type path qui pointe vers les sources du module :

mkdir -p m2-sources/my-own-modules/yourVendorName-yourModuleName
cd m2-sources/my-own-modules/yourVendorName-yourModuleName
git clone git@github.com:yourGitHubName/yourGitHubModule.git ./
ddev composer config repositories.yourVendorName-yourModuleName path my-own-modules/yourVendorName-yourModuleName/
ddev composer require yourComposerModuleName:@dev
ddev magento module:enable yourVendorName_yourModuleName
ddev magento setup:upgrade
ddev magento cache:flush

Pour la suite de cette présentation, je prendrai pour exemple un de mes modules appelé Okaeli_CategoryCode. Celui ci ajoute un attribut code aux catégories, mais peu importe. Si vous souhaitez voir ce que ça donne :

mkdir m2-sources/my-own-modules
mkdir m2-sources/my-own-modules/okaeli-category-code
cd m2-sources/my-own-modules/okaeli-category-code
git clone git@github.com:julienloizelet/magento2-category-code.git ./
ddev composer config repositories.okaeli-category-code path my-own-modules/okaeli-category-code/
ddev composer require okaeli/magento2-category-code:@dev
ddev magento module:enable Okaeli_CategoryCode
ddev magento setup:upgrade
ddev magento cache:flush

Tests statiques et unitaires

Comme mentionné plus haut, un des points forts de DDEV est qu'il permet d'ajouter ses propres commandes. J'ai ainsi pu définir les commandes phpcs, phpmd et phpstan qui lancent les outils du même nom :

• PHP Code Sniffer: ddev phpcs my-own-modules/yourVendorName-yourModuleName
• PHP Mess Detector: ddev phpmd my-own-modules/yourVendorName-yourModuleName
• PHP Stan: ddev phpstan my-own-modules/yourVendorName-yourModuleName

Si vous avez cloné le module exemple Okaeli_CategoryCode dans m2-sources/my-own-modules/okaeli-category-code, il suffit de remplacer yourVendorName-yourModuleName par okaeli-category-code.

J'ai aussi ajouté une commande pour lancer PHPUNIT :

ddev phpunit my-own-modules/yourVendorName-yourModuleName/Test/Unit

Désolé, le module exemple n'a pas de tests unitaires :).

Pour aller plus loin : Cron et Varnish

Si vous voulez voir comment j'ai utilisé DDEV pour tester les crons et Varnish, vous pouvez regarder ici.

Nous venons de voir comment tester un module en local. La mise en place d'actions GitHub découle directement de cette façon de faire :

Étape 3 : Mise en place d'actions GitHub

J'ai commencé à utiliser les actions GitHub en même temps que DDEV. C'est en créant les commandes DDEV que je me suis rendu compte qu'il serait "facile" de les lancer dans une action GitHub. Et je trouve que c'est aussi un gain de temps : les commandes que je crée en local sont directement applicables dans mes actions GitHub.

C'est pourquoi l'action GitHub que j'utilise pour lancer les tests statiques (PHPCS, PHPMD et PHPSTAN) reprend point par point les étapes que je viens de décrire plus haut :

• on installe DDEV
• on installe Magento avec DDEV
• on installe le module avec DDEV
• on lance les tests avec DDEV

La différence principale est qu'on peut jouer sur l'entrée strategy.matrix du fichier yml de l'action pour tester plusieurs versions de Magento et de PHP en même temps.

Voici ce que ça donne pour le module exemple :

• tests statiques

• tests d'installation et de fonctionnement avec Varnish

Petit bonus si vous avez tenu jusque-là : ces tests statiques et Varnish sont proches de ceux exécutés pour la revue technique de la soumission d'un module à la Marketplace (voir ici et ici). Si vous avez un module à soumettre, ça vous évitera peut-être un failed sur cette étape.

Conclusion

Cette présentation est un cas d'usage et ne fait que survoler l'étendue des possibilités de DDEV. J'espère quand même qu'elle vous sera utile si jamais vous souhaitez donner une chance à cet outil.