Raspberry Pi: Come eseguire un Docker Container Apache Karaf 4.2
Tags: blog, containers, raspberrypi, apachekaraf
Published: 2020-09-10 21:17:19

---
title: Raspberry Pi: Come eseguire un Docker Container Apache Karaf 4.2
published: true
date: 2020-08-23 21:45:06 UTC
tags: Blog,Containers,RaspberryPi,ApacheKaraf
canonical_url: https://www.dontesta.it/2020/08/23/raspberry-pi-come-eseguire-docker-container-apache-karaf/
---

Qualche giorno addietro sul [Tech Blog](https://techblog.smc.it) di [SMC](https://www.smc.it) ho pubblicato l’articolo [**Cosa sono gli OSGi Remote µServices**](https://techblog.smc.it/it/2020-07-31/cosa-sono-osgi-remote-services), il cui obiettivo è quello di mostrare come il framework [**OSGi**](https://www.osgi.org/) 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**](https://karaf.apache.org/) 4.2 in forma di [**Container**](https://www.docker.com/resources/what-container) sul [**Raspberry Pi**](https://www.raspberrypi.org/).

[![Figura 1 - Scenario d'esempio di µServices Remoti (da SMC Tech Blog - https://techblog.smc.it)](https://techblog.smc.it/static/79d9f9a153ec49caec329b759f518a27/e3729/scenario-osgi-remote-service-1.png "Figura 1 - Scenario d'esempio di µServices Remoti (da SMC Tech Blog - https://techblog.smc.it)")](https://techblog.smc.it/it/2020-07-31/cosa-sono-osgi-remote-services)

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+](https://www.raspberrypi.org/products/raspberry-pi-3-model-b-plus/), 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**](https://www.raspberrypi.org/documentation/usage/gpio/).

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

- [Raspberry Pi 3 Model B+](https://amzn.to/2EfI16N) (CPU ARM Cortex-A53 a 64 bit quad-core a 1.4GHz con 1GByte di RAM)
- [Raspberry Pi 4](https://amzn.to/3l0KzXf) (CPU ARM Cortex-A72 a 64 bit quad-core a 1.5GHz con 8GByte di RAM)

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**](https://www.raspberrypi.org/downloads/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](https://www.raspberrypi.org/forums/viewtopic.php?t=275370) è 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](https://www.raspberrypi.org/forums/viewtopic.php?t=275370) 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](https://www.dontesta.it/wp-content/uploads/2020/08/output-raspberrypi-3bplus-os-info.png "Figura 2 - Informazioni di dettaglio sul sistema operativo e versione del Kernel")](https://www.dontesta.it/wp-content/uploads/2020/08/output-raspberrypi-3bplus-os-info.png)

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**](https://docs.docker.com/get-docker/) sul Raspberry Pi.

 

## 2. Installazione di Docker

L’installazione di **Docker Engine** è supportata su [Raspbian](https://docs.docker.com/engine/install/debian/) (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](https://docs.docker.com/engine/install/debian/#install-using-the-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](https://www.dontesta.it/wp-content/uploads/2020/08/docker-engine-supported-platform.png "Figura 3 - Docker Engine Supported Platform")](https://www.dontesta.it/wp-content/uploads/2020/08/docker-engine-supported-platform.png)

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](https://docs.docker.com/engine/install/debian/#install-using-the-convenience-script).

 

```
# Download script d'installazione$ curl -fsSL https://get.docker.com -o get-docker.sh# Esecuzione dell'installazione$ sudo sh get-docker.sh# Se desideri utilizzare Docker come utente non root, # dovresti ora considerare di aggiungere il tuo utente # al gruppo "docker"$ sudo usermod -aG docker your-user
```

 

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](https://docs.docker.com/engine/release-notes/#190312). 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.

 

```
...# Executing docker install script, commit: 26ff363bcf3b3f5a00498ac43694bf1c7d9ce16c+ sh -c apt-get update -qq >/dev/null+ sh -c DEBIAN\_FRONTEND=noninteractive apt-get install -y -qq apt-transport-https ca-certificates curl >/dev/null+ sh -c curl -fsSL "https://download.docker.com/linux/raspbian/gpg" | apt-key add -qq - >/dev/null+ sh -c echo "deb [arch=armhf] https://download.docker.com/linux/raspbian buster stable" > /etc/apt/sources.list.d/docker.list+ sh -c apt-get update -qq >/dev/null+ [-n]+ sh -c apt-get install -y -qq --no-install-recommends docker-ce >/dev/null+ sh -c docker versionClient: Docker Engine - Community Version: 19.03.12 API version: 1.40 Go version: go1.13.10 Git commit: 48a6621 Built: Mon Jun 22 15:53:41 2020 OS/Arch: linux/arm Experimental: falseServer: Docker Engine - Community Engine: Version: 19.03.12 API version: 1.40 (minimum version 1.12) Go version: go1.13.10 Git commit: 48a6621 Built: Mon Jun 22 15:47:34 2020 OS/Arch: linux/arm Experimental: false containerd: Version: 1.2.13 GitCommit: 7ad184331fa3e55e52b890ea95e65ba581ae3429 runc: Version: 1.0.0-rc10 GitCommit: dc9208a3303feef5b3839f4323d9beb36df0a9dd docker-init: Version: 0.18.0 GitCommit: fec3683If you would like to use Docker as a non-root user, you should now consideradding your user to the "docker" group with something like: sudo usermod -aG docker your-userRemember that you will have to log out and back in for this to take effect!WARNING: Adding a user to the "docker" group will grant the ability to run containers which can be used to obtain root privileges on the docker host. Refer to https://docs.docker.com/engine/security/security/#docker-daemon-attack-surface for more information....
```

 

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](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-version-raspberry-pi-model-3bplus.png "Figura 4 - Output del comando docker version")](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-version-raspberry-pi-model-3bplus.png)

Figura 4 – Output del comando docker version

 

Verifichiamo tramite l’esecuzione del comando `docker run hello-world`che l’immagine Docker [**hello-world**](https://hub.docker.com/_/hello-world) sia correttamente scaricata da [**Docker Hub**](https://hub.docker.com/), 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](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-run-hello-world-raspberry-pi-model-3bplus.png "Figura 5 - Output dell'esecuzione del comando docker run hello-world")](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-run-hello-world-raspberry-pi-model-3bplus.png)

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**](https://www.raspberrypi.org/documentation/linux/usage/systemd.md). 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](https://docs.docker.com/engine/install/linux-postinstall/). 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](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-systemctl-status-docker-raspberry-pi-model-3bplus-1024x255.png "Figura 6 - Output del comando sudo systemctl status docker")](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-systemctl-status-docker-raspberry-pi-model-3bplus.png)

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**](https://hub.docker.com/r/apache/karaf/tags) 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](https://hub.docker.com/r/amusarra/karaf/tags)** 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](https://www.dontesta.it/wp-content/uploads/2020/08/docker-hub-amusarra-karaf-image-1024x441.png "Figura 7 - Dettagli immagine amusarra/karaf versione 4.2.9")](https://www.dontesta.it/wp-content/uploads/2020/08/docker-hub-amusarra-karaf-image.png)

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](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-pull-and-images-raspberry-pi-model-3bplus.png "Figura 8 - Output del comando docker pull per l'immagine amsurra/karaf:4.2.9 e docker images")](https://www.dontesta.it/wp-content/uploads/2020/08/output-comando-docker-pull-and-images-raspberry-pi-model-3bplus.png)

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)](https://asciinema.org/a/354926?autoplay=1) è possibile vedere l’intera sequenza di comandi in esecuzione.

 

```
# Run dell'immagine docker amusarra/karaf:4.2.9$ docker run -d --name karaf -p 8101:8101 amusarra/karaf:4.2.9# Visualizzazione del container Apache Karaf appena creato$ docker container ls# Visualizzazione dei log in modalità tail $ docker logs -f karaf
```

 

## 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](https://asciinema.org/a/354929?autoplay=1) è 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](https://www.dontesta.it/wp-content/uploads/2020/08/connessione-console-apache-karaf-via-ssh.png "Figura 9 - Connessione alla console di Apache Karaf via SSH")](https://www.dontesta.it/wp-content/uploads/2020/08/connessione-console-apache-karaf-via-ssh.png)

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](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-esecuzione-comando-info.png "Figura 10 - Output del comando info di Apache Karaf")](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-esecuzione-comando-info.png)

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**](http://karaf.apache.org/manual/latest/#_feature_and_resolver) 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**](https://karaf.apache.org/manual/cellar/latest-4/) 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](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-webconsole-bundle-list-1024x245.png "Figura 11 - Apache Karaf Web Console lista dei bundle")](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-webconsole-bundle-list.png)

Figura 11 – Apache Karaf Web Console lista dei bundle

 

[![Figura 12 - Apache Karaf Web Console informazioni di sistema](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-webconsole-system-information-1024x289.png "Figura 12 - Apache Karaf Web Console informazioni di sistema")](https://www.dontesta.it/wp-content/uploads/2020/08/apache-karaf-webconsole-system-information.png)

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](https://asciinema.org/a/354939?autoplay=1)).

 

<script id="asciicast-354939" src="https://asciinema.org/a/354939.js" async></script>

 

## 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](https://dockr.ly/2VYOOWd)) 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**](https://docs.docker.com/buildx/working-with-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](https://hub.docker.com/r/amusarra/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.

L'articolo [Raspberry Pi: Come eseguire un Docker Container Apache Karaf 4.2](https://www.dontesta.it/2020/08/23/raspberry-pi-come-eseguire-docker-container-apache-karaf/) sembra essere il primo su [Antonio Musarra's Blog](https://www.dontesta.it).

[![](http://feeds.feedburner.com/~ff/dontesta/blog?d=yIl2AUoC8zA)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:yIl2AUoC8zA) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=dnMXMwOfBR0)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:dnMXMwOfBR0) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=NwXI_2J6jR4:6PAUrM9Sa7U:D7DqB2pKExk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:D7DqB2pKExk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=YwkR-u9nhCs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:YwkR-u9nhCs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=NwXI_2J6jR4:6PAUrM9Sa7U:F7zBnMyn0Lo)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:F7zBnMyn0Lo) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=NwXI_2J6jR4:6PAUrM9Sa7U:V_sGLiPBpWU)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:V_sGLiPBpWU) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=qj6IDK7rITs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:qj6IDK7rITs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=NwXI_2J6jR4:6PAUrM9Sa7U:KwTdNBX3Jqk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:KwTdNBX3Jqk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=NwXI_2J6jR4:6PAUrM9Sa7U:gIN9vFwOqvQ)](http://feeds.feedburner.com/~ff/dontesta/blog?a=NwXI_2J6jR4:6PAUrM9Sa7U:gIN9vFwOqvQ)
 ![](http://feeds.feedburner.com/~r/dontesta/blog/~4/NwXI_2J6jR4)