Come creare immagini Docker Liferay DXP + Red Hat JBoss EAP

Docker è diventato sempre più popolare nel ciclo di vita di sviluppo odierno, fornendo un modo automatizzato per impacchettare il software e le sue dipendenze in un'unità standardizzata che può essere condivisa su più piattaforme. Per maggiori approfondimenti sull'argomento, consiglio una "puntatina" all'ampia documentazione di Docker.

Con questo articolo voglio prendervi per mano e portavi fino alla costruzione di un'immagine Docker di Liferay DXP installato su Red Hat JBoss EAP. Armatevi di pazienza perché la strada sarà un pochino lunga ma sono sicuro che all'arrivo rimarrete soddisfatti.

L'articolo è incentrato sulla versione 7.2 di Liferay DXP e sulla versione 7.2 di Red Hat JBoss EAP. Qualcuno di voi saprà che il 13 di ottobre 2020 è stata rilasciata la versione 7.3 di Liferay DXP, e sono sicuro che vi farà piacere sapere che ho dedicato l'ultimo capitolo alla creazione dell'immagine con quest'ultima versione di Liferay installata sull'ultima versione di JBoss EAP 7.3.

1. Le immagini Docker standard di Liferay

Liferay fornisce immagini ufficiali Docker per i seguenti prodotti. Queste immagini sono liberamente fruibili e pubblicate sul repository Docker Hub di Liferay. Ad ogni rilascio di prodotto è disponibile la relativa immagine Docker. La figura a seguire mostra appunto le ultime immagini Docker di Liferay DXP versione 7.3.

1. Portale Liferay (Community Edition)
2. Liferay DXP
3. Liferay Commerce
4. Snapshot del portale Liferay

È possibile estrarre le immagini Docker di Liferay dalle risorse indicate in precedenza e gestirle in modo indipendente. Liferay Workspace, tuttavia, fornisce un modo semplice per integrare lo sviluppo Docker nel tuo flusso di lavoro esistente con attività o task Gradle preconfezionate.

Grazie al Liferay Workspace possiamo eseguire le seguenti attività.

1. Creazione di un container Docker basato su un'immagine standard fornita via Docker Hub.
2. Configurazione del container.
3. Interagire con il container.
4. Creazione di un'immagine Liferay personalizzata.

Tutte le informazioni di dettaglio sono disponibili sulla documentazione ufficiale di Liferay Leveraging Docker. I prossimi paragrafi descrivono in modo sintetico come sono organizzate le immagini prodotte da Liferay.

1.1. Tags

I tag seguono il formato {versione}-{data}. Versione indica la versione di Liferay DXP e data indica la data in cui è stata creata l'immagine Docker. I tag che seguono il formato {versione} puntano sempre all'ultimo tag che segue il formato {versione}-{data}.

Le immagini DXP sono fornite con una licenza di prova di 30 giorni. Le immagini più vecchie verranno eliminate regolarmente e saranno disponibili nuove immagini con una nuova licenza di prova di 30 giorni.

1.2. Runnings

Per avviare Liferay DXP, sostituisci {tag} ed esegui il comando docker run -it -p 8080:8080 liferay/dxp:{tag}

L'argomento -it consente di arrestare il container con la combinazione di tasti CTRL-C. Altrimenti, devi usare il comando docker kill {containerId} (o altri equivalenti) per fermare il container.

L'argomento -p 8080:8080 mappa la porta 8080 del container con la porta 8080 dell'host in modo da poter accedere a Liferay DXP utilizzando un browser.

1.3. Evironment Variables

È possibile ottimizzare i parametri della JVM di default impostando la variabile di ambiente LIFERAY_JVM_OPTS.

Puoi personalizzare il comportamento di Liferay DXP tramite variabili d'ambiente che fanno riferimento alle proprietà di configurazione definite sul file portal.properties. Ad esempio, se desideri configurare l'istanza Liferay solo per la lingua inglese e portoghese, puoi adottare una delle seguenti strategie:

1. creare il file portal-ext.properties con la voce locales.enabled=en_US, pt_BR;
2. impostare la variabile d'ambiente LIFERAY_LOCALES_PERIOD_ENABLED=en_US, pt_BR.

Le variabili d'ambiente hanno la precedenza su portal.properties. La rispettiva variabile d'ambiente di ciascuna proprietà è documentata all'interno del file portal.properties.

1.4. File System

Per testare rapidamente le modifiche senza creare una nuova immagine, mappare il file system dell'host al file system del contenitore.

Avvia il container con l'opzione -v $(pwd)/xyz123:/mnt/liferay per collegare $(pwd)/xyz123 nel sistema operativo host a /mnt/liferay sul container. Ricordo che PWD sta per Pathname Working Directory.

I file nella directory host $(pwd)/xyz123/files sono disponibili anche nella directory del contenitore /mnt/liferay/files e verranno copiati in /opt/liferay prima dell'avvio di Liferay DXP.

Ad esempio, se desideri modificare il file setenv.sh di Tomcat, inserisci le modifiche in $(pwd)/xyz123/files/tomcat/bin/setenv.sh, in questo modo il file setenv.sh verrà sovrascritto in /opt/liferay/tomcat/bin/setenv.sh prima dell'avvio di Liferay DXP.

1.5. Scripts

Tutti gli script nella directory del container /mnt/liferay/scripts verranno eseguiti prima dell'avvio di Liferay DXP. È possibile per esempio installare degli script che fanno pulizia delle directory di cache prima che il portale salga su. Posiziona i tuoi script in $(pwd)/xyz123/scripts.

1.6. Deploy

Copia i file in $(pwd)/xyz123/deploy sul sistema operativo host per installare i moduli (o bundle) su Liferay DXP in fase di runtime. La directory può essere utilizzata per installare il file della licenza, quest'ultima necessaria per poter utilizzare il prodotto.

2. Estensione del progetto liferay-docker

Liferay produce le proprie immagini Docker ufficiali tramite il progetto pubblicato su GitHub che sia chiama liferay-docker, progetto non molto diffuso al grande pubblico. Le immagini prodotte sono però esclusivamente create partendo dal bundle con Apache Tomcat.

La necessità è invece quella di realizzare un'immagine Docker in cui Liferay sia installato su JBoss EAP. È opportuno però creare la nuova immagine mantenendo i "servizi offerti" dalle immagini ufficiali prodotte da Liferay (vedi: file system, variabili di ambiente, supporto per l'esecuzione di script pre-start, etc.).

Per raggiungere quest'obiettivo basta estendere il progetto liferay-docker affinché sia possibile:

1. eseguire la build dell'immagine Docker in cui Liferay sia installato su JBoss EAP;
2. eseguire il push dell'immagine Docker creata verso un repository;
3. eseguire l'installazione del Patching Tool, Fix Pack, Hot Fix e Security Fix Pack di Liferay direttamente in fase di build;
4. eseguire l'installazione della Patch di JBoss EAP.

L'oggetto dell'estensione è lo script build_local_image.sh. Questo è responsabile dell'esecuzione delle operazioni indicate precedentemente, di cui, le ultime sono opzionali. Il diagramma mostrato dalla figura a seguire illustra le varie fasi del processo di costruzione dell'immagine Docker di Liferay.

La creazione dell'immagine Docker segue il processo d'installazione di Liferay su JBoss EAP così come descritto dal documento ufficiale di Liferay chiamato Installing on JBoss EAP.

3. Requisiti

Affinché sia possibile portare a termine con successo la creazione dell'immagine Docker, è necessario che siano rispettati una serie di requisiti software per la macchina dedicata all'operazione di build. I requisiti software da soddisfare sono i seguenti.

1. Sistema Operativo Unix/Linux/macOS. In alternativa è sufficiente avere la disponibilità di una shell Bash (versione 3.x).
2. Docker Engine 18.x o 19.x.
3. Git 2.x (opzionale).
4. JDK 1.8 0 11.

Per quanto riguarda Docker è possibile installare Docker Desktop sulla propria postazione di lavoro, disponibile sia per sistemi operativi Microsoft sia per sistemi operativi Apple. Consiglio l'installazione della versione stable evitando la versione edge, quest'ultima utile per sperimentare le ultime feature.

Nel caso aveste già installato Docker, verificare la versione presente sul sistema utilizzando il comando docker version accertandovi che la versione sia nel range indicato dai requisiti. A seguire è mostrato un esempio di output del comando. In questo caso la versione è la 19.03.13, quindi in linea con quanto richiesto.

Client: Docker Engine - Community
 Cloud integration  0.1.18
 Version:           19.03.13
 API version:       1.40
 Go version:        go1.13.15
 Git commit:        4484c46d9d
 Built:             Wed Sep 16 16:58:31 2020
 OS/Arch:           darwin/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          19.03.13
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.13.15
  Git commit:       4484c46d9d
  Built:            Wed Sep 16 17:07:04 2020
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          v1.3.7
  GitCommit:        8fba4e9a7d01810a393d5d25a3621dc101981175
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683

Il software necessario alla creazione dell'immagine può essere scaricato come archivio liferay-docker-1.0.0.zip.

4. Download dipendenze

Il processo di creazione dell'immagine richiede che siano disponibili i seguenti bundle.

• Liferay DXP WAR
• Liferay DXP Dependencies
• Liferay DXP OSGi Dependencies
• Liferay Patching Tool
• Liferay DXP Fix Pack (opzionale)
• Liferay DXP Hot Fix (opzionale)
• Liferay DXP Security Pack (opzionale)
• Red Hat JBoss EAP
• Red Hat JBoss EAP Patch (opzionale)

I primi cinque bundle in elenco riguardano Liferay e questi devono essere scaricati dal Customer Portal di Liferay, è quindi richiesto un account che sia abilitato all'accesso e download.

I bundle che riguardano, Fix Pack, Hot Fix e Security Pack di Liferay sono opzionali, necessari nel caso in cui vogliate applicare in fase di build dell'immagine Docker di Liferay una specifica Fix Pack, Hot Fix o Security Pack. La figura a seguire mostra la sezione di download del Customer Portal di Liferay.

Per quando riguarda il bundle di JBoss EAP, questo può essere scaricato in versione GA e le eventuali patch dal RedHat Customer Portal.

Per questo articolo, la versione di riferimento di Liferay è la DXP 7.2 SP 3 e quella di RedHat JBoss è la 7.2. La tabella a seguire mostra nel dettaglio l'elenco delle dipendenze richieste (e non quelle opzionali indicate nella precedente lista).

5. Come creare l'immagine

Per creare l'immagine Docker è necessario installare l'estensione del progetto liferay-docker sulla macchina dedicata al processo di build. È inoltre essenziale aver eseguito il download dei bundle indicati in Tabella 1.

I passi basilari per procedere con la creazione dell'immagine sono:

1. installazione dell'estensione del progetto liferay-docker;
2. preparazione della directory che conterrà i bundle di Tabella 1;
3. esecuzione dello script build_local_image.sh.

Lo script build_local_image.sh che avvia il processo di creazione dell'immagine Docker Liferay + JBoss EAP, deve essere eseguito specificando i seguenti parametri:

1. il path relativo che contiene i bundle di Tabella 1;
2. il nome dell'immagine/repository Docker;
3. il nome del tag da assegnare all'immagine;
4. flag che indica se fare il push dell'immagine sul repository Docker (no-push | push);
5. nome dell'application server, il cui valore in questo caso è jboss-eap.

Eseguendo lo script senza fornire alcun parametro, saranno mostrate le modalità d'utilizzo del comando (vedi figura a seguire). Ricordo che lo script resta valido per eseguire la creazione d'immagini Liferay basate sul bundle Apache Tomcat di Liferay.

La Console 2 mostra la sequenza dei comandi necessari per portare a termine con successo la creazione dell'immagine Docker di Liferay installato su JBoss EAP. Il processo di creazione dell'immagine potrebbe richiedere diversi minuti (tra 6 e 8 minuti su CPU: i7 decima generazione 1 Socket 2 Core, RAM: 16GB, Storage SSD).

# 1. Unzip dell'estensione del progetto liferay-docker
$ unzip ~/Downloads/liferay-docker-1.0.0.zip

# 2. Preparazione della directory che conterrà i bundle
$ cd liferay-docker-1.0.0
$ cp -a ~/Downloads/bundles .

# 3. Esecuzione del processo di build dell'immagine
$ ./build_local_image.sh bundles amusarra/liferay-dxp liferay-dxp-7.2.10-sp3 no-push jboss-eap

Al termine dell'esecuzione dello script build_local_image.sh, utilizzando il comando docker images è possibile verificare la nuova immagine appena creata (vedi figura a seguire).

Com'è possibile notare da quanto mostrato in figura, sono stati creati due tag che rispecchiano il pattern indicato in 1.1. Tags che puntano alla medesima immagine (vedi image id). L'immagine Docker così creata è pronta per essere utilizzata.

5.1. Template di configurazione JBoss EAP

JBoss EAP, sui cui è stato installato Liferay, ha ricevuto la configurazione base definita sul documento Installing on JBoss EAP. I file di configurazione base di JBoss EAP sono disponibili all'interno della directory $PROJECT_DIR/template/jboss-eap, così come mostrato nella figura a seguire.

La configurazione di base di JBoss EAP può essere eventualmente modificata secondo le proprie esigenze, così facendo già in fase di creazione dell'immagine è possibile applicare personalizzazioni alla configurazione base.

È consigliato applicare le personalizzazioni alla configurazione di JBoss EAP tramite la configurazione del container (vedi 1.3. Evironment Variables e 1.4. File System).

5.2. Installazione Patching Tool

Nel caso in cui si voglia installare il Patching Tool di Liferay sull'immagine da creare, basta scaricare dal Customer Portal di Liferay l'ultima versione del Patching Tool (per esempio: patching-tool-2.0.15.zip), e posizionare il file zip all'interno della directory contenente il resto dei bundle indicati in Tabella 1.

In fase di creazione dell'immagine, se il Patching Tool è presente, questo sarà installato all'interno della cosiddetta LIFERAY_HOME (vedi figura a seguire).

Durante l'installazione del Patching Tool è eseguita l'operazione di auto-discovery che come conseguenza creerà il file default.properties all'interno della home directory del Patching Tool.

Per maggiori informazioni riguardo l'installazione e l'uso di questo strumento, fare riferimento al documento ufficiale di Liferay che si chiama Installing the Patching Tool.

Nota: In fase di creazione di una nuova immagine è consigliato partire sempre dall'ultima versione disponibile dei bundle Liferay. L'installazione del Patching Tool è essenziale per la creazione di un'immagine a cui applicare le ultime Fix Pack, Hot Fix o Security Fix rilasciate da Liferay. L'applicazione delle fix può essere anche eseguita successivamente alla creazione dell'immagine, per esempio, nel momento i cui sia creato un container Liferay.

5.3. Installazione Liferay Fix Pack

In fase di creazione dell'immagine è possibile applicare le Fix Pack rilasciate da Liferay. Prima di poter installare la Fix Pack è essenziale aver installato il Patching Tool (vedi 5.2. Installazione Patching Tool).

Nota: Quando si decide d'installare una Fix Pack è fondamentale accertarsi che la versione del Patching Tool installata sia compatibile con la Fix Pack che si vuole installare. Quest'informazione è riportata sulla sezione di download della Fix Pack stessa.

Per attivare l'installazione della Fix Pack in fase di creazione dell'immagine, è necessario scaricare la Fix Pack dal Customer Portal di Liferay e posizionare il file zip all'interno della directory contenente il resto dei bundle indicati in Tabella 1.

La figura a seguire mostra l'avvio dell'installazione della Fix Pack subito dopo l'installazione del Patching Tool, e in questo caso si tratta della Fix Pack liferay-fix-pack-dxp-8-7210.zip sulla versione di Liferay 7.2 DXP SP 2.

5.4. Installazione Liferay Hotfix e Security Fix Pack

Così come per l'installazione della Fix Pack, anche Hotfix e Security Fix Pack seguono la stessa procedura d'installazione. Per attivare l'installazione in fase di creazione dell'immagine, è necessario scaricare i relativi file zip dal Customer Portal di Liferay e posizionarli all'interno della directory contenente il resto dei bundle indicati in Tabella 1.

5.5. Installazione Patch di JBoss EAP

Così come avviene per Liferay, anche per JBoss EAP nel processo di creazione dell'immagine Docker, se presente il file zip della patch, questa sarà applicata. La figura a seguire mostra l'applicazione della patch durante il processo di build. In questo caso è stata applicata la patch 7.2.9, questo comporta che la nuova versione di JBoss EAP sarà la 7.2.9.

Quando l'istanza di Liferay è su, è possibile verificare la versione di JBoss EAP dai log stessi dell'application server oppure utilizzando i comandi version e patch info direttamente dalla CLI di JBoss EAP. La figura a seguire mostra il controllo della versione di JBoss EAP, che dopo l'applicazione della patch è passata dalla 7.2.0 alla 7.2.9.

6. Eseguire l'immagine Docker Liferay DXP + JBoss EAP

Per avviare la nuova immagine Docker di Liferay, è possibile utilizzare i comandi standard di Docker. In Console 3 sono mostrati alcuni dei comandi standard per avviare la nuova immagine.

# Avvio dell'immagine amusarra/liferay-dxp:liferay-dxp-7.2.10-sp3 in modalità interattiva esponendo la porta HTTP 8080
$ docker run -it -p 8080:8080 -P amusarra/liferay-dxp:liferay-dxp-7.2.10-sp3

# Avvio dell'immagine amusarra/liferay-dxp:liferay-dxp-7.2.10-sp3 in modalità detached esponendo
# le porte 8000 (DEBUG), 8080 (HTTP) e 11311 (Gogo Shell)
$ docker run -d -p 8000:8000 -p 8080:8080 -p 11311:11311 -P amusarra/liferay-dxp:liferay-dxp-7.2.10-sp3

# Avvio dell'immagine amusarra/liferay-dxp:liferay72-dxp-dev in modalità detached esponendo
# le porte 8000 (DEBUG), 8080 (HTTP) e 11311 (Gogo Shell) e assegnando un nome al container
$ docker run -d --name liferay72jboss -p 8000:8000 -p 8080:8080 -p 11311:11311 -P amusarra:liferay-dxp-7.2.10-sp3

Quando l'immagine viene avviata è possibile vedere le seguenti informazioni che sono mostrate nel dettaglio dalla figura a seguire:

1. come ottenere la console del container appena creato;
2. la versione di JAVA utilizzata per avviare Liferay;
3. la situazione sul file system sul quale è possibile agire attraverso l'uso del Docker Volume.

6.1. Utilizzare Docker Volume

Per agire sulla configurazione di Liferay e di JBoss EAP, evitando così la creazione di nuove immagini, è possibile sfruttare i cosiddetti Docker Volumes montando il file system locale sul container in esecuzione, così come indicato nel capitolo 1.4. File System.

Nel caso in cui volessi per esempio configurare Liferay per utilizzare Oracle come RDBMS, la procedura da seguire è la seguente:

1. preparare il layout file system così come previsto dalle immagini standard di Liferay (vedi File System);

2. revisionare la configurazione di JBoss EAP:

   • modificare il file di configurazione module.xml per aggiungere il riferimento al driver dell'RDBMS, che in questo caso è Oracle;
   • copiare il driver JDBC Oracle sull'installazione di JBoss EAP;

3. aggiungere la configurazione di connessione al database tramite file di properties portal-ext.properties o tramite environment.

La Console 4 mostra i comandi per realizzare il file system layout che conterrà i file di configurazione necessari a connettere Liferay al database Oracle.

# 1. Preparazione del layout file system
$ mkdir liferay-with-jboss-docker-configuration
$ cd liferay-with-jboss-docker-configuration
$ mkdir deploy && mkdir scripts && mkdir files

# 2. Copia del file module.xml revisionato con il riferimento al driver JDBC Oracle
$ mkdir -p files/jboss-eap/modules/com/liferay/portal/main/
$ cp ~/Downloads/module.xml files/jboss-eap/modules/com/liferay/portal/main/

# 3. Copia del driver JDBC Oracle
$ cp ~/Downloads/ojdbc8.jar files/jboss-eap/modules/com/liferay/portal/main/

# 4. Copia del file portal-ext.properties con la configurazione di connessione al database Oracle
$ cp ~/Downloads/portal-ext.properties files/

La figura a seguire mostra la struttura del file system appena creato e che sarà montato come Docker Volume, così come indicato dal comando illustrato in Console 5. Da notare che fanno parte del layout anche le directory deploy e scripts, che rispettivamente sono dedicate all'hot-deploy dei moduli o bundle e all'esecuzione di scripts pre-start Liferay.

# Esecuzione di Liferay con la connessione verso il database Oracle
$ docker run -d --name liferay72jboss -p 8080:8080 -p 11311:11311 -v $(pwd):/etc/liferay/mount -P amusarra/liferay-dxp:liferay-dxp-7.2.10-sp3

La figura a seguire evidenzia la copia dei file di configurazione sul file system del container che sono stati predisposti in precedenza.

6.2. Installazione Liferay Fix Pack

Esiste la possibilità d'installare una Fix Pack durante lo start-up del container. All'interno del capitolo 5. Come creare l'immagine è stato spiegato come installare una Fix Pack durante il processo di creazione dell'immagine.

Applicare una Fix Pack su di una immagine esistente può essere un vantaggio nel caso in cui si voglia verificare in modo agevole la "bontà" della Fix Pack, soprattutto in quei casi dov'è fondamentale il controllo di eventuali regressioni sul software custom.

Il requisito per l'installazione della Fix Pack secondo questa modalità, è la presenza dell'installazione del Patching Tool sull'immagine base a cui s'intende applicare la Fix Pack (vedi 5.2. Installazione Patching Tool) e la configurazione del container utilizzando i Docker Volumes (vedi 6.1. Utilizzare Docker Volume). Al layout del file system occorre quindi aggiungere la directory patching all'interno della quale posizionare il file zip della Fix Pack. La figura a seguire mostra come al layout del file system precedente è stata aggiunta la directory patching e aggiunto il file della Fix Pack che desideriamo installare.

Eseguendo il comando mostrato a seguire, questa volta, oltre ad applicare la configurazione per la connessione ad Oracle, prima che Liferay sia avviato, sarà applicata la Fix Pack che risiede all'interno della directory patching.

# Esecuzione di Liferay con l'applicazione della Fix Pack
$ docker run -d --name liferay72jboss -p 8080:8080 -p 11311:11311 -v $(pwd):/etc/liferay/mount -P amusarra/liferay-dxp:liferay-dxp-7.2.10-fp-8

Dai log di start del container Docker, dovreste vedere l'applicazione della Fix Pack e successivamente l'avvio del portale Liferay. La figura a seguire mostra appunto un esempio di applicazione della Fix Pack.

Per accertarsi dell'avvenuta e corretta installazione della Fix Pack, basta ottenere l'accesso alla macchina per poi utilizzare il comando ./patching-tool.sh info (dalla directory d'installazione del Patching Tool) per verificare che la Fix Pack per cui è stata chiesta l'installazione è presente sul sistema.

6.3 Installazione Liferay Hotfix e Security Fix Pack

Allo stesso modo di com'è possibile installare la Fix Pack di Liferay durante lo start-up del container, è anche possibile farlo per Hotfix e Security Fix Pack. Restano quindi valide le indicazioni descritte in 5.3. Installazione Liferay Fix Pack.

7. Uno scenario reale

Tenendo ben in mente quanto descritto ampiamente sul capitolo 5. Come creare l'immagine, vedremo quali sono i passi per creare la propria immagine Docker di Liferay + JBoss EAP, ipotizzando lo scenario a seguire.

Ipotizziamo di voler realizzare un'immagine Docker di Liferay DXP 7.2 SP 2 con JBoss EAP 7.2.0 come application server e di voler applicare la Fix Pack Liferay dxp-8-7210 e la patch 7.2.9 JBoss EAP. Per ottenere questo risultato occorre procedere con gli step mostrati dal diagramma mostrato a seguire.

Assumiamo di aver eseguito con successo il primo step ed il secondo step, per i quali consiglio di rivedere i capitoli 3. Requisiti e 4. Download dipendenze. Per il resto degli step, eseguire nell'ordine, da console (Bash) i comandi indicati.

# Step 3.1 Installazione dell'estensione del progetto liferay-docker
#  - Il file zip del progetto https://github.com/smclab/liferay-docker/archive/v1.0.0.zip
$ unzip ~/Downloads/liferay-docker-1.0.0.zip

# Step 3.2 Inizializzazione del Repository Git
#  - Sostituire la URL del repository Git con la propria
#  - Assegnare al branch un nome che sia possibilmente esplicativo
$ cd liferay-docker-1.0.0
$ git init
$ git add .
$ git remote add origin https://github.com/smclab/liferay-docker.git
$ git commit -m "Initial import liferay-docker image builder"
$ git checkout -b build/liferay-dxp-7.2.10-fp-8

# Step 3.3 Preparazione della directory che conterrà i bundle
$ cp -a ~/Downloads/bundles .

# Step 4 Esecuzione del processo di build dell'immagine
#  - specificare il nome del proprio repository (in questo caso sostituire amusarra)
#  - la versione del tag dell'immagine docker deve essere possibilmente esplicativa.
#    in questo caso è liferay-dxp-7.2.10-fp-8 che corrisponde con il nome del branch
$ ./build_local_image.sh bundles amusarra/liferay-dxp liferay-dxp-7.2.10-fp-8 no-push jboss-eap

Al termine dello step 4, quindi dell'esecuzione dello script build_local_image.sh, utilizzando il comando docker images è possibile verificare la nuova immagine appena creata (vedi figura a seguire).

L'esecuzione dello step 3.2 è del tutto opzionale ai fini della creazione dell'immagine Docker. Il vantaggio d'inizializzare l'ambiente di build come repository Git, risiede nel fatto che una volta accertato il funzionamento dell'immagine appena creata, dopo aver eseguito le operazioni di commit e push, possiamo in qualunque momento eseguire la build della specifica versione dell'immagine.

Altro vantaggio nell'uso di Git per il versioning della creazione delle immagini è subito evidente utilizzando il comando docker image inspect <imageid>. Le label dell'immagine Docker riportano informazioni circa l'hash del commit e la url del repository, così come mostrato dalla figura a seguire.

# Step 1 Clone del repository liferay-docker e checkout del branch di versione
#  - Sostituire la URL del repository Git con la propria
$ git clone -b build/liferay-dxp-7.2.10-fp-8 https://github.com/smclab/liferay-docker.git

# Step 2 Esecuzione del processo di build dell'immagine
$ cd liferay-docker
$ ./build_local_image.sh bundles amusarra/liferay-dxp liferay-dxp-7.2.10-fp-8 no-push jboss-eap

Al fine di eseguire una verifica dell'immagine appena creata, è sufficiente lanciare il comando docker run -it {<imageid>|<image name>}. Dai log mostrati in console siamo in grado di verificare se l'istanza Liferay non dovesse salire correttamente.

Utilizzando il comando docker ps, e guardando la colonna status dovremmo vedere inizialmente il valore health: starting che dovrebbe diventare healthy quando il servizio Liferay è su, così come mostrato dalle due figure a seguire.

Una volta effettuate tutte le verifiche circa la bontà dell'immagine, è possibile procedere con l'operazione di commit e push dei file modificati sul repository Git e successivamente con il push dell'immagine appena creata sul repository Docker.

Per le successive operazioni di creazione dell'immagine, l'operatività è semplificata considerando che non è più necessario installare l'estensione liferay-docker e quanto meno inizializzare il repository Git. In Console 9 sono mostrate le operazioni da seguire nel caso in cui abbiate già compiuto altre build.

# Step 1 Clone del repository liferay-docker e creazione di un nuovo branch di build immagine Liferay
#  - Sostituire la URL del repository Git con la propria
$ git clone https://github.com/smclab/liferay-docker.git
$ git checkout -b build/liferay-dxp-7.2.10-sp-3

# Step 2 Preparazione della directory che conterrà i bundle per Liferay DXP 7.2 SP 3
$ cd liferay-docker
$ cp -a ~/Downloads/bundles .

# Step 3 Esecuzione del processo di build dell'immagine
$ ./build_local_image.sh bundles amusarra/liferay-dxp liferay-dxp-7.2.10-sp-3 no-push jboss-eap

8. Creare un'immagine con Liferay DXP 7.3

Ci siamo! Come promesso ad inizio articolo vediamo come creare l'immagine Docker utilizzando la nuova versione di Liferay DXP rilasciata 13 ottobre 2020.

Il procedimento rimane assolutamente invariato (vedi Figura 20 - Step essenziali per la creazione dell'immagine Docker Liferay DXP + JBoss EAP). Il primo passo è il download dei file di Liferay DXP 7.3 da scaricare dal Customer Portal di Liferay.

Il file sono quelli indicati a seguire.

1. Liferay DXP Dependencies: liferay-dxp-dependencies-7.3.10-ga1-20200930160533946.zip
2. Liferay DXP OSGi Dependencies: liferay-dxp-osgi-7.3.10-ga1-20200930160533946.zip
3. Liferay DXP WAR: liferay-dxp-7.3.10-ga1-20200930160533946.war
4. Liferay Patching Tool: patching-tool-2.0.15.zip

Il Patching Tool dovreste averlo già scaricato nel caso in cui abbiate fatto una delle precedenti build per Liferay DXP 7.2. Per quel che riguarda la versione 7.3 non è necessario scaricare altro; appena uscita, per cui non ci sono Fix Pack anche se consigliato installare comunque il Patching Tool. La figura a seguire mostra la sezione download per Liferay DXP 7.3, con in evidenza i tipi di file di cui eseguire il download.

Dal documento della Matrice di Compatibilità di Liferay DXP 7.3 possiamo notare la compatibilità con l'Application Server Red Hat JBoss EAP 7.3. È ragionevole pensare d'installare Liferay DXP 7.3 su JBoss EAP 7.3.

Spostiamoci quindi sul Customer Portal di Red Hat per eseguire il download dei seguenti file che riguardano la nuova versione di JBoss EAP 7.3.

1. Red Hat JBoss Enterprise Application Platform 7.3: jboss-eap-7.3.0.zip
2. Red Hat JBoss Enterprise Application Platform 7.3 Patch: jboss-eap-7.3.3-patch.zip

Le due figure a seguire mostrano i file da scaricare che riguardano JBoss EAP 7.3.

Nuova versione di JBoss e nuovo template di configurazione (vedi 5.1. Template di configurazione JBoss EAP) di cui trovate i relativi file sull'estensione del progetto liferay-docker.

Per quel che riguarda Liferay non ci sono modifiche sostanziali da apportare rispetto alla pracedente versione, rimane sempre valida la documentazione Installing on JBoss EAP. La figura a seguire mostra la struttura del template di configurazione per JBoss EAP 7.3.

Riguardo la configurazione specifica di Liferay, l'unico cambiamento apportato con la nuova versione riguarda il file module.xml, a cui sono state aggiunte due nuove risorse, com.liferay.petra.sql.dsl.api.jar e com.liferay.petra.sql.dsl.spi.jar.

<module name="com.liferay.portal" xmlns="urn:jboss:module:1.8">
    <resources>
        <resource-root path="com.liferay.petra.concurrent.jar" />
        <resource-root path="com.liferay.petra.executor.jar" />
        <resource-root path="com.liferay.petra.function.jar" />
        <resource-root path="com.liferay.petra.io.jar" />
        <resource-root path="com.liferay.petra.lang.jar" />
        <resource-root path="com.liferay.petra.memory.jar" />
        <resource-root path="com.liferay.petra.nio.jar" />
        <resource-root path="com.liferay.petra.process.jar" />
        <resource-root path="com.liferay.petra.reflect.jar" />
        <resource-root path="com.liferay.petra.sql.dsl.api.jar" />
        <resource-root path="com.liferay.petra.sql.dsl.spi.jar" />
        <resource-root path="com.liferay.petra.string.jar" />
        <resource-root path="com.liferay.registry.api.jar" />
        <resource-root path="portal-kernel.jar" />
        <resource-root path="portlet.jar" />
        <resource-root path="hsql.jar" />
        <resource-root path="ojdbc8.jar" />
    </resources>
    <dependencies>
        <module name="javax.api" />
        <module name="javax.mail.api" />
        <module name="javax.servlet.api" />
        <module name="javax.servlet.jsp.api" />
        <module name="javax.transaction.api" />
    </dependencies>
</module>

A questo punto dovremmo avere tutti i bundle richiesti a nostra disposizione, possiamo quindi procedere con la creazione dell'immagine. Il risultato atteso sarà l'immagine di Liferay DXP 7.3 GA1 installata su JBoss EAP 7.3.

Partendo dal presupposto di avere l'estensione del progetto liferay-docker in forma di repository Git (vedi 7. Uno scenario reale), proseguiamo così come indicato in Console 10 per ottenere la nuova immagine.

# Step 1 Clone del repository liferay-docker e creazione di un nuovo branch di build immagine Liferay
#  - Sostituire la URL del repository Git con la propria
$ git clone https://github.com/smclab/liferay-docker.git
$ git checkout -b build/liferay-dxp-7.3.10-ga1

# Step 2 Preparazione della directory che conterrà i bundle per Liferay DXP 7.3 GA 1
$ cd liferay-docker
$ cp -a ~/Downloads/bundles-dxp-73 .

# Step 3 Esecuzione del processo di build dell'immagine
$ ./build_local_image.sh bundles-dxp-73 amusarra/liferay-dxp liferay-dxp-7.3.10-ga1 no-push jboss-eap

Le prime due figure a seguire mostrano durante il processo di creazione dell'immagine , l'applicazione della patch a JBoss EAP 7.3 e l'installazione del Patching Tool di Liferay.

Utilizzando il comando docker images è possibile verificare la presenza sul sistema della nuova immagine appena creata amusarra/liferay-dxp:liferay-dxp-7.3.10-ga1.

8.1. Test della nuova immagine Liferay DXP 7.3

Al fine di eseguire una verifica dell'immagine appena creata, è sufficiente lanciare il comando docker run -it {<imageid>|<image name>}. Dai log mostrati in console siamo in grado di verificare se l'istanza Liferay non dovesse salire correttamente. La figura a seguire mostra che il container è salito correttamente, vedi la colonna STATUS.

Potremmo per esempio connetterci al container e successivamente verificare tramite la console di JBoss EAP se la patch è stata applicata.

Se provassimo ad effettuare una connessione al portale tramite il browser, verrebbe richiesta l'installazione della licenza. Ricordo che le immagini così create sono senza licenza; per utilizzare il portale, occorre installare il file della licenza copiandolo all'interno della directory deploy.

9. Risorse

L'estensione del progetto liferay-docker è disponibile sul repository GitHub di SMC.

A seguire lascio una serie di risorse che sono il punto di riferimento per i contenuti di quest'articolo.

1. Leveraging Docker
2. Creating a Liferay DXP Docker Container
3. Configuring a Docker Container
4. Deploying Liferay DXP Using Docker
5. How to build a Docker Liferay 7.2 image with the Oracle Database support

10. Conclusioni

Ben arrivati alla fine! Per esseri giunti fino in fondo alla lettura di questo articolo, sono abbastanza sicuro che vi siate trovati nella situazione di dover creare un'immagine di Liferay, dove Liferay sia installato su di un Application Server diverso da Apache Tomcat, o che siate in procinto di dover affrontare quest'attività.

Mi son trovato più volte in questa situazione, e la strada che ho voluto indicare con questo articolo è quella che ritengo più vantaggiosa, soprattutto in termini di semplicità nella fase di creazione dell'immagine e in ultimo, l'immagine così ottenuta è conforme a quelle prodotte da Liferay stessa.

Voi come avete affrontato questo tema? Discutiamone insieme.