Raspberry Pi: Come eseguire un Docker Container Apache Karaf 4.2

Qualche giorno addietro sul Tech Blog di SMC ho pubblicato l’articolo Cosa sono gli OSGi Remote µServices, il cui obiettivo è quello di mostrare come il framework OSGi può essere utilizzato in modo efficace nel contesto dei Microservices. Lo scenario d’esempio di µServices Remoti proposto nell’articolo (vedi figura a seguire), prevede che uno dei container OSGi sia in esecuzione sul Raspberry Pi.

Avete mai pensato di eseguire uno o più Docker Container sul vostro Raspberry Pi? In questo articolo vedremo come fare per riuscire ad eseguire un’istanza di Apache Karaf 4.2 in forma di Container sul Raspberry Pi.

Figura 1 - Scenario d'esempio di µServices Remoti (da SMC Tech Blog - https://techblog.smc.it)

Figura 1 – Scenario d’esempio di µServices Remoti (da SMC Tech Blog – https://techblog.smc.it)

 

1. Requisiti

Vediamo quali sono i requisiti necessari affinché sia possibile raggiungere il nostro obiettivo. In questo caso parliamo di requisiti sia in termini hardware sia in termini software. Per quanto riguarda l’hardware prendiamo in considerazione il Raspberry Pi e come modello di riferimento la versione 3 Model B+.

Il Raspberry Pi 3 Model B+, anche se con 1GByte di memoria RAM, può essere utilizzato tranquillamente in un contesto Docker, ovviamente, dobbiamo considerare il fatto che le risorse richieste in termini hardware per eseguire le applicazioni sono superiori rispetto ad eseguire le stesse direttamente (senza l’ausilio di Docker).

Una nota importante. Dal momento in cui decidiamo di containerizzare le nostre applicazioni su Raspberry Pi, dobbiamo essere consapevoli del fatto che andiamo incontro ad alcune restrizioni, come per esempio l’accesso diretto al sistema di GPIO.

Per la stesura di questo articolo ho utilizzato il seguente hardware.

Certamente il Raspberry Pi 4 carrozzato con ben 8GByte di memoria RAM lascia parecchio spazio per l’esecuzione di più applicazioni sfruttando per l’appunto Docker; non siamo limitati al solo Apache Karaf ma potremmo realizzare un intero stack di servizi (web server, database, application server, etc.).

Per quel che riguarda i requisiti software di base ci limitiamo a considerare il sistema operativo installato sul Raspberry Pi. Generalmente consiglio d’installare Raspberry Pi OS, sistema operativo gratuito basato su Debian e ottimizzato per l’hardware del Raspberry Pi. L’ultima versione disponibile al momento è stata rilasciata a maggio 2020 con versione del Kernel 4.19 (Debian Buster), questa sarà la nostra versione di riferimento. Solitamente prediligo l’installazione della versione Lite alla versione Desktop.

Entrambe i modelli di Raspberry Pi hanno il processore a 64 bit, sarebbe quindi possibile installare il sistema operativo a 64 bit. Sulla versione 3 non ha senso installare il sistema operativo a 64 bit visto che la memoria RAM disponibile è di 1GByte. Avrebbe senso installare la versione a 64 bit del sistema operativo, sul Raspberry Pi 4 per il modello dotato di 8GByte di memoria RAM.

In questo momento la versione a 64 bit di Raspberry Pi OS è disponibile solo in versione beta. La nostra versione di riferimento sarà comunque la versione a 32 bit. Il post Raspberry Pi OS (64 bit) beta test version sul forum ufficiale spiega da dove scaricare la versione a 64 bit e la procedura d’installazione.

Prima di andare oltre, accertiamoci che nel frattempo non siano stati rilasciati aggiornamenti per la distribuzione di Raspberry Pi OS, in caso procediamo con l’aggiornamento. Possiamo aggiornare la distribuzione utilizzando il comando sudo apt update && sudo apt dist-upgrade.

La figura a seguire mostra il contenuto del file /etc/os-release e l’output del comando uname -a. Da notare l’aggiornamento della versione del Kernel, dalla versione 4.9 alla versione 5.4.

 

Figura 2 - Informazioni di dettaglio sul sistema operativo e versione del Kernel

Figura 2 – Informazioni di dettaglio sul sistema operativo e versione del Kernel

 

Una volta che siamo certi che i requisiti del sistema operativo siano soddisfatti, possiamo proseguire con l’installazione di Docker Community Edition sul Raspberry Pi.

 

2. Installazione di Docker

L’installazione di Docker Engine è supportata su Raspbian (Raspberry PI OS). Per Raspberry Pi OS non è supportato il metodo d’installazione utilizzando i repository (così come indicato sulla documentazione), bensì il metodo cosiddetto convenience script. Docker Engine è supportato per le architetture hardware x86_64 (o amd64), armhf, e arm64. La figura a seguire mostra la lista delle piattaforme software (sistemi operativi) supportate per l’installazione di Docker Engine.

 

Figura 3 - Docker Engine Supported Platform

Figura 3 – Docker Engine Supported Platform

 

La procedura d’installazione tramite il convenience script è davvero semplice e si conclude in pochi semplici passi che sono mostrati a seguire. Consiglio in ogni caso la lettura attenta della documentazione di Docker riguardo questo metodo d’installazione.

 

 

A seguire parte dell’output che dovreste ottenere eseguendo lo script d’installazione get-docker.sh. Dall’output finale possiamo identificare la versione di Docker Engine installata, che in questo caso è la 19.03.12 e i più curiosi possono leggere le release notes. Come anche indicato al termine dell’installazione, possiamo procedere con l’esecuzione del comando che ci eviterà l’utilizzo del sudo prima di ogni comando docker. Ricordo che questa è un opzione, attivarla o no, dipende dalle proprie necessità legate spesso alle questioni di sicurezza.

 

 

Nel caso in cui sia stato eseguito il comando che aggiunge il vostro utente (per esempio quello di default pi) al gruppo docker, prima di eseguire ogni altro comando che riguarda Docker, dovreste effettuare nuovamente l’accesso. Effettuato nuovamente l’accesso, eseguiamo il comando docker version per verificare che effettivamente non ci siano stati problemi in fase d’installazione. La figura a seguire mostra quello che dovreste ottenere dall’esecuzione del comando indicato.

 

Figura 4 - Output del comando docker version

Figura 4 – Output del comando docker version

 

Verifichiamo tramite l’esecuzione del comando docker run hello-worldche l’immagine Docker hello-world sia correttamente scaricata da Docker Hub, creato correttamente il container e eseguito. L’esecuzione del comando senza errori indica che:

  1. il client Docker ha contattato il daemon Docker;
  2. il daemon Docker ha estratto (operazione di pull) l’immagine hello-world da Docker Hub (arm32v7);
  3. il daemon Docker ha creato un nuovo container da quell’immagine e che l’esecuzione produce l’output che stai attualmente leggendo;
  4. il daemon Docker ha trasmesso l’output al client Docker, che lo ha inviato al tuo terminale.

La figura a seguire mostra l’output che dovreste ottenere dall’esecuzione del comando docker run hello-world. Ultima verifica che potremmo fare è quella del container creato dall’immagine hello-world utilizzando il comando docker container ls -a.

 

Figura 5 - Output dell'esecuzione del comando docker run hello-world

Figura 5 – Output dell’esecuzione del comando docker run hello-world

 

Lo script d’installazione prevede la configurazione di Docker Engine come servizio, questo significa che da questo momento in poi, Docker Engine sarà avviato ad ogni boot del Raspberry Pi e in ogni caso il servizio può essere gestito tramite systemctl. La figura a seguire riporta l’output del comando sudo systemctl status docker che ci da informazioni circa lo stato del servizio Docker Engine.

Consiglio di fare riferimento al documento Post-installation steps for Linux. Questa sezione di documentazione contiene tutte quelle procedure facoltative per configurare gli host Linux per far funzionare al meglio Docker. Non solo, questo documento è utile anche in caso troubleshooting.

 

Figura 6 - Output del comando sudo systemctl status docker

Figura 6 – Output del comando sudo systemctl status docker

 

Direi che a questo punto Docker Engine dopo le opportune verifiche che abbiamo seguito sembra funzionare a dovere, possiamo quindi andare oltre con l’installazione ed esecuzione dell’immagine Docker di Apache Karaf 4.2.

 

3. Setup dell’immagine Docker Apache Karaf

L’immagine ufficiale apache/karaf supporta solo l’architettura linux/amd64, questo significa che non possiamo utilizzare quest’immagine sul nostro Raspberry Pi (sia la versione 3 sia la versione 4).

È fattibile quindi eseguire Apache Karaf in forma di container Docker?

Certamente! Per l’occasione ho preparato l’immagine amusarra/karaf che può essere utilizzata esclusivamente per le architetture ARM (linux/arm/v7 e linux/arm64) e che include Java 11 invece di Java 8. L’immagine Docker è disponibile e pronta all’uso sul mio repository Docker Hub. La figura a seguire mostra tutti i dettagli. La versione di Apache Karaf è la 4.2.9.

 

Figura 7 - Dettagli immagine amusarra/karaf versione 4.2.9

Figura 7 – Dettagli immagine amusarra/karaf versione 4.2.9

 

Procediamo con il comando docker pull amusarra/karaf:4.2.9 per eseguire il pull dell’immagine. Al termine dell’operazione di pull, avremo localmente l’immagine di Apache Karaf 4.2.9 per linux/arm. Possiamo verificare l’effettiva architettura utilizzando il comando docker image inspect --format "{{.Os}}/{{.Architecture}}" amusarra/karaf:4.2.9, il cui output atteso dovrebbe essere: linux/arm. La figura a seguire mostra l’operazione di pull dell’immagine e successivamente la lista delle immagini Docker che abbiamo in locale, tra cui è evidenziata la nuova immagine amusarra/karaf:4.2.9.

 

Figura 8 - Output del comando docker pull per l'immagine amsurra/karaf:4.2.9 e docker images

Figura 8 – Output del comando docker pull per l’immagine amsurra/karaf:4.2.9 e docker images

 

Molto bene! Non rimane altro che eseguire l’immagine amusarra/karaf:4.2.9 utilizzando il comando a seguire (il primo della lista). Su Run Apache Karaf 4.2.9 on Raspberry Pi 3 Model B+ (ARM/v7) è possibile vedere l’intera sequenza di comandi in esecuzione.

 

 

4. Connessione alla console di Apache Karaf

Adesso che l’istanza di Apache Karaf è attiva in forma di container Docker, possiamo provare ad effettuare una connessione alla console di Apache Karaf via ssh. La porta standard della console ed esposta (vedi comando docker run) è la 8101. Utilizzando il commando ssh -p 8101 karaf@127.0.0.1 direttamente dalla shell del Raspberry Pi, dovremmo ottenere l’accesso alla console di Apache Karaf. La password di default di accesso alla console è karaf.

La figura a seguire mostra l’avvenuta connessione con successo alla console di Apache Karaf via ssh. È possibile eseguire la connessione alla console anche al di fuori della shell del Raspberry Pi, l’importate è verificare che non ci siano regole di rete che ne possano impedire la connessione. Su Connect to Apache Karaf Console (running on Raspberry Pi) via ssh è possibile vedere l’intera sequenza di connessione alla console di Apache Karaf da una macchina presente sulla stessa rete del Raspberry Pi.

 

Figura 9 - Connessione alla console di Apache Karaf via SSH

Figura 9 – Connessione alla console di Apache Karaf via SSH

 

A questo punto facciamo un’ultima verifica che tutto sia in ordine. Dalla console di Apache Karaf digitiamo ed eseguiamo il comando info. Questo comando restituisce informazioni di sistema del runtime su cui l’istanza di Apache Karaf è in esecuzione.

  • Informazioni generali su Apache Karaf.
  • Informazioni sulla JVM.
  • Informazioni sui Threads.
  • Informazioni circa l’allocazione di memoria.
  • Informazioni circa le classi java del sistema.
  • Informazioni sul Sistema Operativo.

Quello che dovremmo ottenere dall’output del comando info è mostrato dalla figura a seguire. Da notare la sezione Operating System, dov’è evidente l’architettura ARM ed i quattro core del processore (in questo caso il Cortex-A53 del Raspberry Pi 3 Model B+).

 

Figura 10 - Output del comando info di Apache Karaf

Figura 10 – Output del comando info di Apache Karaf

 

5. Installazione Apache Karaf Web Console

Adesso che la nostra istanza di Apache Karaf in esecuzione in forma di container Docker, vediamo d’installare qualcosa di utile, come per esempio la console Web di Apache Karaf. La procedura d’installazione è davvero semplice, si tratta una feature di Apache Karaf.

La Web Console fornisce una GUI web grafica per vedere e gestire il container OSGi Apache Karaf. È possibile utilizzare la Web Console per i seguenti scopi:

  • gestire le funzionalità di Apache Karaf;
  • gestire i bundle OSGi;
  • gestire le istanze;
  • gestire le configurazioni;
  • gestire il Service Registry.

La Web Console è estendibile tramite un sistema di plugin. Alcune applicazioni possono aggiungere nuove pagine alla WebConsole. Ad esempio, Apache Karaf Cellar fornisce pagine aggiuntive per amministrare gruppi di cluster, nodi, ecc.

L’installazione della Web Console consiste nei seguenti passi.

  1. Rimozione del precedente container. Questa operazione è necessaria perchè adesso il nuovo container dovrà esporre anche la porta 8080, su questa la Web Console sarà in listen.
  2. Creazione e start del nuovo container in modo che esporti la porta 8080.
  3. Connessione alla console di Apache Karaf via ssh.
  4. Installazione della Web Console tramite il comando feature:install webconsole.
  5. Connessione alla Web Console via browser all’indirizzo http://<ip-raspberry-pi>:8080/system/console. Le credenziali di accesso di default sono karaf/karaf.

Le due figure a seguire mostrano alcune delle informazione che la Web Console può offrire, in questo caso sono visualizzati i bundle installati sul sistema e le informazioni del sistema.

 

Figura 11 - Apache Karaf Web Console lista dei bundle

Figura 11 – Apache Karaf Web Console lista dei bundle

 

Figura 12 - Apache Karaf Web Console informazioni di sistema

Figura 12 – Apache Karaf Web Console informazioni di sistema

 

A seguire è possibile vedere la sequenza di tutti i passi che sono stati eseguiti sul sistema per installare con successo la Web Console di Apache Karaf (Install WebConsole on Apache Karaf – running on Raspberry Pi).

 

 

6. Conclusioni

Pensavate che fosse possibile installare Docker anche su architetture hardware ARM?

Grazie alla partnership tra Docker e ARM (vedi Docker announced a partnership with Arm) annunciata nel mese di aprile del 2019, oggi, siamo stati in grado di eseguire il container Docker di Apache Karaf sull’architettura linux/arm del Raspberry Pi.

Grazie a buildx (di Docker) possiamo quindi creare immagini multi-arch sia per ARM sia per x86 utilizzando Docker Desktop. Utilizzando buildx, sono riuscito a prepare l’immagine di Apache Karaf per linux/arm64 e linux/arm/v7 che abbiamo poi usato per installare il servizio di Apache Karaf sul Raspberry Pi.

È sempre grazie a questa partnership ch’è stato possibile installare Docker anche sul Raspberry Pi, e come avete avuto modo di notare è una procedura molto semplice da portare a termine con successo.

Questa possibilità apre una miriade di strade verso soluzioni davvero interessanti e quella che ho voluto presentare in questo articolo è una delle tante. Alcuni sono stati dubbiosi sull’uscita del Raspberry Pi 4 con 8GByte di RAM, nel senso che a loro avviso è troppa memoria; cosa ci vuoi fare! Ecco, con tutta questa RAM a disposizione, un sistema operativo a 64bit e Docker, le cose interessanti da sviluppare non mancano di certo.

In un prossimo articolo vi mostrerò come ho realizzato l’immagine di Apache Karaf per ARM utilizzando il tool buildx di Docker. Nell’attesa vi invito a commentare l’articolo nel caso vogliate porre delle domande sul contenuto appena letto.

28 Condivisioni

Antonio Musarra

I began my journey into the world of computing from an Olivetti M24 PC (http://it.wikipedia.org/wiki/Olivetti_M24) bought by my father for his work. Day after day, quickly taking control until … Now doing business consulting for projects in the enterprise application development using web-oriented technologies such as J2EE, Web Services, ESB, TIBCO, PHP.

Potrebbero interessarti anche...

Cos'è il progetto CIE/CNS Apache Docker - Developers Italia

In questo video https://youtu.be/TcAzn1POhsM introdurrò il progetto CIE/CNS Apache Docker di Developers Italia (https://developers.italia.it/it/cie/#resourcecontent-3) nato circa due anni fa.

L'obiettivo di questo progetto è quello di fornire un template pronto all'uso che realizza un sistema di autenticazione tramite la Smart Card TS-CNS (o CNS) e la CIE (Carta d'Identità Elettronica) basato su Apache HTTP. Ognuno può poi modificare o specializzare questo progetto sulla base delle proprie esigenze Si tratta di un progetto docker per la creazione di un container che implementa un sistema di mutua autenticazione o autenticazione bilaterale SSL/TLS.

Questo meccanismo di autenticazione richiede anche il certificato digitale da parte del client, certificato che in questo caso risiede all'interno della TS-CNS o della CIE. La particolarità del sistema implementato (attraverso questo container) è quella di consentire l'autenticazione tramite:

  • La TS-CNS (Tessera Sanitaria - Carta Nazionale Servizi), rilasciata dalla regione di appartenenza;
  • La CIE (Carta d'Identità Elettronica), rilasciata dal comune di residenza.

Nella versione 2.0.0 il progetto è stato aggiornato per essere uniforme alle linee guida di Bootstrap Italia. A seguire alcune risorse che possono essere utili.

  • Cos’è il progetto CIE/CNS Apache Docker (http://bit.ly/3aJ5Gbl)
  • CIE Carta d'Identità Elettronica (https://developers.italia.it/it/cie/)
  • Carta Nazionale dei Servizi (https://www.agid.gov.it/it/piattaforme/carta-nazionale-servizi)
  • Raspberry Pi – Un esempio di applicazione della TS-CNS (https://bit.ly/3hkJ8Aj)
  • Pubblicare il servizio CIE/CNS Apache Docker su Azure Cloud (http://bit.ly/3aPoq8V)
  • Come accedere al portale VETINFO tramite TS-CNS e Mac OS (http://bit.ly/2VFMKq7)