[#if coverImage??]
    [#if coverImage?is_hash]
        [#if coverImage.alt??]
            ${coverImage.alt}
        [/#if]
    [/#if]
[/#if]

Introduction

Fin 2020, Apple sortait les premières machines basées sur le processeur M1 Silicon, d’architecture ARM64. Certains d’entre vous auront certainement vécu les difficultés de trouver des applications compatibles.

Les images Docker proposées par Liferay n'échappent pas à ce piège. Les images produites par Liferay avant la version 7.4.3ga19 (oui, oui, les versions 6.2, 7.2 ou 7.3) ne sont pas compatibles avec les processeurs de type ARM et ne peuvent donc être exécutées sur les puces M1. Ceci oblige les développeurs à dévier des environnements standardisés grâce à la conteneurisation, ou à changer de machine de travail. Et cela implique des surcoûts...

Pour résoudre ce problème, Docker propose la solution BuildX pour construire des images supportant plusieurs architectures de processeurs.

Mais avant tout, pourquoi?

En réalité, le portail Liferay est tout à fait compatible avec l’architecture ARM64. Après tout, la première solution pour contourner le problème est de revenir aux bonnes vieilles installations directes sur le système d’exploitation… Et ça marche!

L’origine du problème se situe dans la variante de la JVM intégrée dans les images construites par Liferay. L’image de base est un conteneur Ubuntu standard. Et la variante de la JVM ajoutée est explicitement limitée aux architectures AMD64 (voir DOCKER-108 sort · liferay/liferay-docker@73f9b53). Cette dépendance dure ne permet donc pas à Docker Engine une interaction avec les instructions natives du processeur M1.

Partant de ce constat, la stratégie sera de créer des images multi-architecture grâce à BuildX.

BuildX

Docker BuildX peut être défini comme un plugin CLI qui ajoute aux commandes Docker standard les fonctionnalités supplémentaires anciennement embarquées dans le BuildKit de Moby (GitHub - moby/buildkit: concurrent, cache-efficient, and Dockerfile-agnostic builder toolkit). La syntaxe est conçue pour offrir la même expérience utilisateur que la construction via docker build.

Docker BuildX est basé sur les capacités binfmt_misc du noyau Linux, combinées à l'émulateur QEMU pour créer des images multi-arch.

Une image multi-architecture est un type d’image conteneur qui peut combiner des variantes pour différentes architectures, voire différents systèmes d’exploitation. Lorsque l’image est exécutée, le client de conteneur (typiquement Docker Engine) sélectionne automatiquement la variante de l’image qui correspond au système d’exploitation et à l'architecture de l'hôte.

Composition d’une image Liferay

L'image Liferay est composée de 3 images superposées :

  • Zulu-openjdk:11, tirée d’une image Ubuntu officielle (depuis Liferay 7.4; auparavant, il s’agissait d’un Linux Alpine)

  • Base, construite sur la précédente

  • Bundle, intégrant à l’image Base un bundle Liferay-Tomcat

Zulu-openjdk:11

Cette image est basée sur une image ubuntu:focale ou ubuntu:jammy plus récemment. Java 11 est installé sur cette image et JAVA_HOME pointe vers le répertoire /usr/lib/jvm/zulu11-ca-amd64 ce qui limite automatiquement le type de processeur à AMD64.

Base

Cette image est construite sur l’image zulu-openjdk:11. En plus de java 11, java 8 est installé, et elle contient les scripts de configuration de l’environnement Liferay.

Bundle

Cette image est basée sur l'image Base, et elle contient le bundle Liferay-Tomcat, en plus de configurations par défaut pour le portail Liferay. C'est donc l'image Liferay initiale, que nous utilisons tous les jours et que nous retrouvons sur DockerHub: https://hub.docker.com/r/liferay/portal .

Création de l’image Liferay prenant en charge l’architecture ARM64

Comme indiqué dans la section précédente, l'image de base zulu-openjdk:11 ne fonctionne que sur les processeurs AMD64. Elle doit donc être réimaginée pour prendre en charge le type de processeur ARM64. Pour ce faire, nous avons suivi plusieurs étapes:

  • Changer le JAVA_HOME de /usr/lib/jvm/zulu11-ca-amd64 à /usr/lib/jvm/zulu11-ca-arm64 au niveau du Dockerfile
  • Construire l’image avec BuildX : docker buildx build -t <nom de l'image:tag> --platform linux/arm64 .

Notez que le package zulu installé prend en charge tous les types de processeurs, ce qui facilite la bascule entre les variables d'environnement.

On peut vérifier le type de processeur du conteneur exécutant cette image en tapant la commande uname -p dans le conteneur.

Après avoir créé l'image zulu-openjdk:11, l'image 'Base' sera construite d’une manière classique, sans BuildX, car elle est basée sur une image qui supporte le type ARM64.

Pour ce faire, nous avons apporté quelques modifications:

  • Changer la variable d’environnement JAVA_VERSION de ENV JAVA_VERSION=zulu8-ca-amd64 à ENV JAVA_VERSION=zulu8-ca-arm64
  • Construire l’image sans BuildX : docker build -t <nom de l'image:tag> .

L'image 'Bundle' est basée sur l'image 'Base' et est créée sans aucune modification du Dockerfile et de manière normale, sans BuildX: docker build -t <nom de l'image:tag> .

En définitive, l'image Liferay construite ne prend en charge que les machines d’architecture ARM64.

Structure du projet Liferay ARM64

liferay-arm64/
├── base
│   ├── Dockerfile
│   ├── home
│   │   └── .bashrc
│   └── scripts
│   ├── configure_liferay.sh
│   ├── _liferay_common.sh
│   ├── liferay_entrypoint.sh
│   ├── patch_liferay.sh
│   ├── probe_thread_dump.sh
│   ├── set_java_version.sh
│   └── start_liferay.sh
├── bundle
│   ├── Dockerfile
│   └── liferay*
└── zulu
└── Dockerfile

Les fichiers Dockerfile initiaux et les scripts “.sh” et “.bashrc” peuvent être téléchargés à partir de https://github.com/liferay/liferay-docker/tree/master/templates/jdk11.

(*) Le répertoire liferay correspond au bundle souhaité.

OK, et Liferay dans tout ça?

En parallèle de nos travaux, l'éditeur de Diamond Bar a modifié de son côté la formation des images Docker pour le portail. A partir de la version 7.4.3ga19… La stratégie adoptée est également construite autour de BuildX pour la préparation de l’image de base incluant la JVM Zulu11. Les environnements et les cas de figure envisagés par Liferay sont bien entendu très divers et requièrent une configuration extensive, apte à produire des images officielles à l'épreuve des balles. Pour des raisons liées à cette couverture, Liferay a choisi de ne pas rééditer les versions précédentes des images. Le travail présenté ici garde tout son sens pour ce besoin temporaire.

Conclusion

Avec le plugin Docker BuildX, il devient possible et relativement facile pour tout le monde de créer et de publier des images Docker qui fonctionnent sur plusieurs architectures de processeur.

Actuellement, les images Liferay prennent en charge les types de processeur AMD et ARM, mais avant la version 7.4.3ga19, seule l’architecture AMD64 est prise en charge. L'équipe de Beorn Technologies a donc développé un script pour créer des images Liferay (toutes versions) pour pallier l’absence de version compatible ARM. Vous l’obtiendrez via https://github.com/royalsarkis/liferay-arm64.git

 

Autheur: Roy SARKIS

Fait le : 26/04/2022