ActiveMQ Artemis: Easy Docker Creation also for ARM
Tags: blog, iot, arm, docker
Published: 2021-05-10 08:55:41

---
title: ActiveMQ Artemis: Easy Docker Creation also for ARM
published: true
date: 2021-02-15 17:35:19 UTC
tags: Blog,IoT,ARM,Docker
canonical_url: https://www.dontesta.it/2021/02/15/activemq-artemis-easy-docker-creation-also-for-arm/
---

Da diverso tempo realizzo progetti che ruotano nell’intorno dell’ecosistema [**IoT** (Internet Of Things)](https://en.wikipedia.org/wiki/Internet_of_things) utilizzando delle [**SBC** (Single Board Computer)](https://en.wikipedia.org/wiki/Single-board_computer) come il [**Raspberry Pi**](https://www.raspberrypi.org/). All’interno dell’ecosistema IoT il [**Message Broker**](https://en.wikipedia.org/wiki/Message_broker#:~:text=A%20message%20broker%20is%20an,exchange%20messages%2C%20effectively%20implementing%20decoupling.) e uno di quei componenti, direi fondamentali, che abilitano le comunicazioni tra i “pezzi di ferro”.

Il protocollo [**MQTT**](https://mqtt.org/) è di fatto il re della connettività **machine-to-machine (M2M)**, divenuto sempre più popolare con l’evoluzione e la divulgazione dei concetti IoT. Il protocollo MQTT può essere pensato come un analogo leggero e semplificato di [**AMQP**](https://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol), anch’esso basato sul modello [**publish/subscribe**](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern), ma fornisce un footprint di rete molto più piccolo e può essere utilizzato da dispositivi di piccole dimensioni e con limitate capacità di calcolo.

Esistono molti Message Broker MQTT Open Source e a pagamento disponibili per l’uso, come ad esempio:

- [Mosquitto](https://mosquitto.org/)
- [HiveMQ](https://www.hivemq.com/)
- [Apache ActiveMQ](https://activemq.apache.org/)
- [RabbitMQ](https://www.rabbitmq.com/)
- [Erlang MQTT](https://www.erlang-solutions.com/capabilities/emqx/) (EMQ)

**Apache ActiveMQ**   è uno tra i più diffusi Message Broker Open Source, multi-protocollo, basato su Java. Supporta i protocolli standard del settore in modo che gli utenti ottengano i vantaggi delle scelte dei client su un’ampia gamma di linguaggi e piattaforme. Attualmente sono disponibili due “versioni” di ActiveMQ: il broker “classico” 5.x e il broker Artemis di “nuova generazione” per applicazioni di messaggistica basate sugli eventi ([**event-driven messaging applications**](https://en.wikipedia.org/wiki/Event-driven_messaging)). Quando Artemis raggiungerà un livello sufficiente di parità di funzionalità con la base di codice 5.x, diventerà ActiveMQ 6.

Nei miei progetti utilizzo solitamente RabbitMQ (ma anche [CloudAMQP](https://www.dontesta.it/2019/08/04/raspberry-pi-sense-hat-come-pubblicare-dati-cloudamqp-mqtt/)) e Apache ActiveMQ. Recentemente ho iniziato a fare qualche esperimento con Apache ActiveMQ Artemis installato come Message Broker su Raspberry Pi.

In questo articolo desidero mostrarvi come realizzare la propria immagine Docker di Apache ActiveMQ Artemis per piattaforme [**ARM**](https://en.wikipedia.org/wiki/ARM_architecture) e di conseguenza eseguibili su Raspberry Pi.

 

## 1. Da dove iniziare?

Si parte andando sulla home page del progetto [ActiveMQ Artemis](https://activemq.apache.org/components/artemis/), e poi da qui, puntiamo subito alla sezione  **Easy Docker Creation**.

ActiveMQ Artemis fornisce alcuni semplici script per iniziare a lavorare con Docker. Per fare in modo che sia possibile generare le proprie immagini Docker anche per piattaforme ARM, circa due settimane fa ho avuto modo di dare un contributo al progetto ActiveMQ Artemis, estendendo il modulo [artemis-docker](https://github.com/apache/activemq-artemis/tree/master/artemis-docker).

Prima di proseguire oltre vediamo quali sono i requisiti:

1. git è opzionale. In caso è possibile scaricare da GitHub il progetto in formato [zip](https://github.com/apache/activemq-artemis/archive/master.zip);
2. JDK 8 o 11. È consigliato creare le proprie immagini Docker SNAPSHOT utilizzando la JDK 11 per la build dei sorgenti, visto che il modulo artemis-docker consente di creare immagini Docker per ARM partendo dall’immagine di [**AdoptOpenJDK 11**](https://adoptopenjdk.net/);
3. Maven 3.x è opzionale. In caso è possibile utilizzare il wrapper Maven (mvnw) incluso all’interno del progetto;
4. Docker 19.x/20.x;
5. [Docker Buildx](https://docs.docker.com/buildx/working-with-buildx/). Per le versioni di Docker dalla 19.03, buildx è incluso, non è necessario installarlo in modo separato;
6. Repository su Docker Hub dove ospitare le immagini Docker che andremo a creare. È necessario per poi rendere agevole l’installazione dell’immagine Docker creata sul vostro Raspberry Pi.

Iniziamo dunque eseguendo il clone del progetto ActiveMQ Artemis. Per il nostro scopo possiamo anche eseguite il clone del repository Git del progetto senza portarci dietro tutta la cronologia: `git clone --depth 1 https://github.com/apache/activemq-artemis.git`

 

## 2. Creiamo la nostra immagine Docker

Grazie al modulo [artemis-docker](https://github.com/apache/activemq-artemis/tree/master/artemis-docker), abbiamo una serie di opzioni per ottenere diverse immagini Docker:

1. creare l’immagine Docker per la release ufficiale di ActiveMQ Artemis;
2. creare l’immagine Docker per la distribuzione locale, ovvero, per la versione SNAPSHOT ottenuta dalla build dei sorgenti;
3. creare l’immagine Docker basata su immagini CentOS e Debian con Java 8;
4. creare l’immagine Docker basata su Ubuntu con Java 11 nell’implementazione di AdoptOpenJDK;
5. creare l’immagine Docker per ARM (ARMv7/ARM64).

Il [readme.md](https://github.com/apache/activemq-artemis/blob/master/artemis-docker/readme.md) del modulo artemis-docker descrive chiaramente come perseguire le opzioni sopra elencante. Noi ci concentreremo su come creare l’immagine Docker per ARM, sia per la release ufficiale di ActiveMQ Artemis sia per la versione SNAPSHOT, quest’ultima utile al fine di provare le nuove funzionalità prima del rilascio della versione ufficiale.

La creazione dell’immagine Docker per ARM per la versione SNAPSHOT prevede i seguenti step. L’attuale versione di SNAPSHOT (al momento della pubblicazione di questo articolo) è la 2.18.0.

1. Clone del repository di ActiveMQ Artemis.
2. Build del progetto per ottenere la distribuzione SNAPSHOT.
3. Preparazione dei Docker file per la distribuzione locale.
4. Build dell’immagine Docker per ARM e push sul repository Docker Hub.

Il tempo di build del progetto è variabile in base alla potenza di calcolo della propria macchina, per esempio, sul mio Mac Book Pro (Mid-2017) i7-7660U con 16GByte di RAM è di circa 5 minuti (senza l’esecuzione di unit test). L’operazione di build dell’immagine Docker spende il tempo maggiore nelle operazioni di push e pull, e questo dipende dalla connettività che si ha a disposizione verso la rete internet.

Nel caso in cui non aveste una buona connettività di rete, potreste incorrere in errori di questo tipo:

1. failed to compute cache key: failed commit on ref “layer-sha256:f60421c1f”: failed size validation: 2292149 != 24043427: failed precondition
2. net/http: TLS handshake timeout
3. failed to copy: unexpected status: 504 Gateway Time-out

 

A seguire sono indicati i comandi necessari per soddisfare i quattro step sopra descritti.

 

```
# 1. Clone the repository
$ git clone --depth 1 https://github.com/apache/activemq-artemis.git

# 2. Build of the project
$ cd activemq-artemis

# If you want skip the test use the -DskipTests argument
$ mvn clean install

# 3. Prepare the Docker file
$ cd artemis-docker
$ ./prepare-docker.sh --from-local-dist --local-dist-path ../artemis-distribution/target/apache-artemis-2.18.0-SNAPSHOT-bin/apache-artemis-2.18.0-SNAPSHOT

# 4. Build the Docker image for ARM. You should replace the {your-username} and {your-repository-name} placeholders with your values
$ cd ../artemis-distribution/target/apache-artemis-2.18.0-SNAPSHOT-bin/apache-artemis-2.18.0-SNAPSHOT
$ docker buildx build --platform linux/arm64,linux/arm/v7 --push -t {your-username}/{your-repository-name}:2.18.0-SNAPSHOT -f ./docker/Dockerfile-adoptopenjdk-11 .
```

 

Se l’esecuzione dello script **prepare-docker.sh** (step 3) va a buon fine, a schermo dovreste vedere quando mostrato dalla figura a seguire, ovvero, gli script (Docker file e script per l’esecuzione del container) che sono stati creati all’interno della directory docker che a sua volta si trova all’interno della directory di distribuzione di ActiveMQ Artemis, inoltre, troverete le informazioni utili per proseguire con la build dell’immagine Docker.

 

[![Figure 1 - Docker image build preparation script output](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_prepare_docker_local_distribution-1024x534.png "Figure 1 - Docker image build preparation script output")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_prepare_docker_local_distribution.png)

Figure 1 – Docker image build preparation script output

 

Per il comando di build dell’immagine Docker (step 4), dovreste sostituire i placeholder **{your-username}** / **{your-repository-name}** con i vostri valori. Nel mio caso questo si traduce in  **amusarra/apache-artemis**.

 

[![Figure 2 - Execution of the buildx command to generate the Docker image for ARM](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_buildx_release_snapshot-1024x355.png "Figure 2 - Execution of the buildx command to generate the Docker image for ARM")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_buildx_release_snapshot.png)

Figure 2 – Execution of the buildx command to generate the Docker image for ARM

 

Dopo l’esecuzione dello step 4, dovreste vedere sul vostro repository Docker Hub l’immagine di ActiveMQ Artemis versione 2.18.0-SNAPSHOT. La figura a seguire mostra in particolare il contenuto del mio repository amusarra/apache-artemis.

 

[![Figure 3 - The content of the Docker Hub repository amusarra/apache-artemis after build and push](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_repository_docker_hub-1024x717.png "Figure 3 - The content of the Docker Hub repository amusarra/apache-artemis after build and push")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_repository_docker_hub.png)

Figure 3 – The content of the Docker Hub repository amusarra/apache-artemis after build and push

 

Se volessimo invece preparare l’immagine Docker di ActiveMQ Artemis versione 2.16.0 (l’attuale versione di release), gli step si riduco a due:

1. preparazione dei Docker file per la versione release (in questo caso la 2.16.0);
2. build dell’immagine Docker per ARM e push sul vostro repository Docker Hub.

 

```
# 1. Prepare the Docker file
$ cd artemis-docker
$ ./prepare-docker.sh --from-release --artemis-version 2.16.0
# 2. Build the Docker image for ARM
$ cd _TMP_/artemis/2.16.0
$ docker buildx build --platform linux/arm64,linux/arm/v7 --push -t {your-username}/{your-repository-name}:2.16.0 -f ./docker/Dockerfile-adoptopenjdk-11 .
```

 

La figura a seguire mostra l’output dello script **prepare-docker.sh** che a differenza della prima esecuzione, scarica la versione 2.16.0 di ActiveMQ Artemis e successivamente mostra gli script (Docker file e script per l’esecuzione del container) che sono stati creati all’interno della directory docker (che a sua volta e contenuta dentro la directory \_TMP\_/artemis/2.16.0/docker), inoltre, mostra le informazioni utili per proseguire con la build dell’immagine Docker.

 

[![Figure 4 - Docker image build preparation script output](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_prepare_docker_release-1024x580.png "Figure 4 - Docker image build preparation script output")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_prepare_docker_release.png)

Figure 4 – Docker image build preparation script output

 

A questo punto dovreste avere sul vostro repository Docker Hub la versione 2.16.0 e 2.18.0-SNAPSHOT di ActiveMQ Artemis.

 

[![Figure 5 - Execution of the buildx command to generate the Docker image for ARM](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_buildx_release-1024x348.png "Figure 5 - Execution of the buildx command to generate the Docker image for ARM")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_buildx_release.png)

Figure 5 – Execution of the buildx command to generate the Docker image for ARM

 

## 3. Raspberry Pi: Pull e Run

**Finalmente ci siamo!** Siete pronti a fare il pull dell’immagine dal nostro repository Docker e successivamente ottenere un container che esegue un’istanza di ActiveMQ Artemis?.

Prima di procedere dobbiamo soddisfare un requisito: **Docker 19.x/20.x deve essere correttamente installato sul Raspberry Pi**. Riguardo il modello di Raspberry Pi consiglio la versione 4 e il modello con almeno 4GByte di memoria RAM. Nel mio caso ho un Raspberry Pi 4 con 8GByte di RAM, sistema operativo Ubuntu 20.04.02 LTS e Docker 20.10.3.

 

[![Figure 6 - Raspberry Pi 4 system information by neofetch](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_rpi_system_info_by_neofetch.png "Figure 6 - Raspberry Pi 4 system information by neofetch")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_rpi_system_info_by_neofetch.png)

Figure 6 – Raspberry Pi 4 system information by neofetch

 

Una volta soddisfatti i requisiti è possibile eseguire il pull e run del container ActiveMQ Artemis utilizzando i comandi a seguire. Eseguiamo il pull di entrambe le versioni delle immagini Docker, anche se poi andremo ad utilizzare la versione 2.16.0.

 

```
# 1. Pull the Docker Images of the ActiveMQ Artemis (2.16.0 and 2.18.0-SNAPSHOT)
$ docker pull amusarra/apache-artemis:2.18.0-SNAPSHOT
$ docker pull amusarra/apache-artemis:2.16.0
# 2. Run the ActiveMQ Artemis 2.16.0
$ docker run --rm -d --name activemq-artemis-2160 -p 61616:61616 -p 8161:8161 -p 1883:1883 amusarra/apache-artemis:2.16.0
```

 

Nel comando di esecuzione del container, specifichiamo quali porte TCP/IP devono essere esportate all’esterno, in questo caso: console (8161), MQTT (1883) e Multi-Protocol [CORE,MQTT,AMQP,STOMP,HORNETQ,OPENWIRE] (61616).

La figura a seguire mostra i log del container ActiveMQ Artemis appena avviato correttamente. Le altre figure mostrano l’accesso al pannello di amministrazione di ActiveMQ Artemis, le cui credenziali di accesso (di default) sono artemis/artemis.

 

[![Figure 7 - View the logs of the ActiveMQ Artemis Docker container](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_docker_container_logs-1024x451.png "Figure 7 - View the logs of the ActiveMQ Artemis Docker container")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_docker_container_logs.png)

Figure 7 – View the logs of the ActiveMQ Artemis Docker container

 

[![Figure 8 - Login page of the ActiveMQ Artemis Management Console](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_loging-1024x637.png "Figure 8 - Login page of the ActiveMQ Artemis Management Console")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_loging.png)

Figure 8 – Login page of the ActiveMQ Artemis Management Console

 

[![Figure 9 - ActiveMQ Artemis view current status](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_system_info-1024x659.png "Figure 9 - ActiveMQ Artemis view current status")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_system_info.png)

Figure 9 – ActiveMQ Artemis view current status

 

## 4. Un test molto veloce ma efficace

Adesso che abbiamo messo in piedi sul Raspberry Pi il nostro Message Broker basato su ActiveMQ Artemis, proviamo a fare un semplice test che consiste in:

1. creare un **topic** dove un **producer** invierà un messaggio (in formato JSON) contenente la temperatura della CPU;
2. creare un producer che legge ogni 5 secondi la temperatura della CPU e invia il valore letto sul topic creato in precedenza;
3. sottoscriversi al topic per leggere i valori pubblicati.

Chiameremo il topic con il nome **RPI4.cpu-temp** che andremo a creare utilizzando il primo comando a seguire. Il comando successivo è invece quello responsabile di leggere la temperatura della CPU ogni 5 secondi e pubblicare in il messaggio sul topic appena creato. Entrambe i comandi fanno uso del binario [**artemis**](https://github.com/apache/activemq-artemis/blob/master/docs/user-manual/en/using-server.md) che fa parte dei tool di gestione del server.

 

```
# 1. Create the topic RPI4.cpu-temp
$ docker exec -it activemq-artemis-2160 \
/bin/bash ./bin/artemis queue create --user artemis --password artemis \
--address RPI4 --anycast --durable --purge-on-no-consumers \
--auto-create-address --name cpu-temp

# 2. Send CPU Temperature on the topic RPI4.cpu-temp
$ while true; \
do docker exec -it activemq-artemis-2160 \
/bin/bash ./bin/./artemis producer --clientID rpi4 --destination topic://RPI4.cpu-temp --message "$(echo -n '{"cpu-temperature":'; cat /sys/class/thermal/thermal_zone*/temp | sed -e 's/\(.\)..$/.\1/'; echo -n '}')" --message-count 1 --user artemis --password artemis; \
sleep 5; \
done
```

 

La figura a seguire mostra il comando di pubblicazione del messaggio sul topic RPI4.cpu-temp in azione. Accedendo alla Management Console è possibile invece vedere alcune informazioni di dettaglio riguardo il numero di sessioni, il numero di connessioni e vedere quali sono gli attuali consumer del topic.

 

[![Figure 10 - Produce message to topic RPI4.cpu-temp](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_execute_command_producer_message_of_cpu_temperature-1024x222.png "Figure 10 - Produce message to topic RPI4.cpu-temp")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_execute_command_producer_message_of_cpu_temperature.png)

Figure 10 – Produce message to topic RPI4.cpu-temp

 

[![Figure 11 - Browse the Session on the ActiveMQ Artemis](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_sessions-1024x269.png "Figure 11 - Browse the Session on the ActiveMQ Artemis")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_sessions.png)

Figure 11 – Browse the Session on the ActiveMQ Artemis

 

[![Figure 12 - Browse the Consumer on the ActiveMQ Artemis](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_consumer-1024x528.png "Figure 12 - Browse the Consumer on the ActiveMQ Artemis")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_consumer.png)

Figure 12 – Browse the Consumer on the ActiveMQ Artemis

 

[![Figure 13 - Browse the Connection on the ActiveMQ Artemis](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_connection-1024x274.png "Figure 13 - Browse the Connection on the ActiveMQ Artemis")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_management_console_browser_connection.png)

Figure 13 – Browse the Connection on the ActiveMQ Artemis

 

Per sottoscriversi al topic RPI4.cpu-temp al fine di poter leggere i valori di temperatura della CPU, potremmo per semplicità, utilizzare un comunissimo client MQTT. Nel mio caso ho utilizzato su macOS l’applicazione [MQTT Explorer](http://mqtt-explorer.com/), di cui a seguire sono mostrate le figure che riguardano la configurazione della connessione verso il Message Broker e la visualizzazione dei dati ricevuti, anche in forma grafica.

 

[![Figure 14 - MQTT Explorer Connection configuration](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_connection_configuration_1-1024x724.png "Figure 14 - MQTT Explorer Connection configuration")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_connection_configuration_1.png)

Figure 14 – MQTT Explorer Connection configuration

 

[![Figure 15 - MQTT Explorer add the topic RPI4.cpu-temp](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_configuration_topic_1.png "Figure 15 - MQTT Explorer add the topic RPI4.cpu-temp")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_configuration_topic_1.png)

Figure 15 – MQTT Explorer add the topic RPI4.cpu-temp

 

[![Figure 16 - MQTT Explorer view data on the RPI4.cpu-temp](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_view_data_grapth_cpu_temperature-1024x615.png "Figure 16 - MQTT Explorer view data on the RPI4.cpu-temp")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_mqtt_explore_view_data_grapth_cpu_temperature.png)

Figure 16 – MQTT Explorer view data on the RPI4.cpu-temp

 

Sul mio iPhone ho utilizzato l’app [MQTT Analyzer](https://github.com/philipparndt/mqtt-analyzer) ma esistono comunque app simili anche per la piattaforma Android, come per esempio [MQTT Terminal](https://play.google.com/store/apps/details?id=com.mightyit.mqttclientterminal&hl=en&gl=US). Le figure a seguire mostrano alcune schermate dell’app mentre legge i valori dal topic RPI4.cpu-temp.

 

[![Figure 17 - MQTT Analyzer Connection Settings](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_ios_mqtt_analyzer_connection-300x650.png "Figure 17 - MQTT Analyzer Connection Settings")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_ios_mqtt_analyzer_connection.png)

Figure 17 – MQTT Analyzer Connection Settings

 

[![Figure 18 - MQTT Analyzer Reading the value on the topic RPI4.cpu-temp](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_ios_mqtt_analyzer_topic_data_series-300x650.png "Figure 18 - MQTT Analyzer Reading the value on the topic RPI4.cpu-temp")](https://www.dontesta.it/wp-content/uploads/2021/02/activemq_artemis_ios_mqtt_analyzer_topic_data_series.png)

Figure 18 – MQTT Analyzer Reading the value on the topic RPI4.cpu-temp

 

A questo punto direi che possiamo ritenerci soddisfatti del risultato ottenuto. Con questo Message Broker le possibili applicazioni in ambito IoT sono davvero innumerevoli, spazio alla fantasia.

 

## 5. Risorse

A seguire vi lascio una serie di risorse che sono utili a scopo di approfondimento.

1. Home del progetto ActiveMQ Artemis ([https://activemq.apache.org/components/artemis/](https://activemq.apache.org/components/artemis/))
2. Easy Docker Creation ([https://github.com/apache/activemq-artemis/tree/master/artemis-docker](https://github.com/apache/activemq-artemis/tree/master/artemis-docker))
3. Apache ActiveMQ Artemis Documentation ([https://activemq.apache.org/components/artemis/documentation/](https://activemq.apache.org/components/artemis/documentation/))
4. [Raspberry PI Sense HAT: Come pubblicare i dati su CloudAMQP via MQTT](https://www.dontesta.it/2019/08/04/raspberry-pi-sense-hat-come-pubblicare-dati-cloudamqp-mqtt/)
5. [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/)
6. [Docker: How to create Apache Karaf images for ARM and ARM64](https://www.dontesta.it/2020/09/10/docker-how-to-create-apache-karaf-images-for-arm-and-arm64/)
7. Internet of Things with Raspberry Pi 3 ([https://www.packtpub.com/product/internet-of-things-with-raspberry-pi-3/9781788627405](https://www.packtpub.com/product/internet-of-things-with-raspberry-pi-3/9781788627405))
8. Practical Python Programming for IoT ([https://www.packtpub.com/product/practical-python-programming-for-iot/9781838982461](https://www.packtpub.com/product/practical-python-programming-for-iot/9781838982461))

 

## 6. Conclusioni

**Pensavate che fosse così semplice installare Apache ActiveMQ Artemis 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 ActiveMQ Artemis 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. Grazie al tool buildx, siamo riusciti a prepare l’immagine di ActiveMQ Artemis per **linux/arm64**  e  **linux/arm/v7** che abbiamo poi usato per installare il servizio di Message Broker multi-protocollo sul Raspberry Pi.

 

L'articolo [ActiveMQ Artemis: Easy Docker Creation also for ARM](https://www.dontesta.it/2021/02/15/activemq-artemis-easy-docker-creation-also-for-arm/) 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=sW9_qASq1-0:mvRYvlHjFAc:yIl2AUoC8zA) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=dnMXMwOfBR0)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:dnMXMwOfBR0) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=sW9_qASq1-0:mvRYvlHjFAc:D7DqB2pKExk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:D7DqB2pKExk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=YwkR-u9nhCs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:YwkR-u9nhCs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=sW9_qASq1-0:mvRYvlHjFAc:F7zBnMyn0Lo)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:F7zBnMyn0Lo) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=sW9_qASq1-0:mvRYvlHjFAc:V_sGLiPBpWU)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:V_sGLiPBpWU) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=qj6IDK7rITs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:qj6IDK7rITs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=sW9_qASq1-0:mvRYvlHjFAc:KwTdNBX3Jqk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:KwTdNBX3Jqk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=sW9_qASq1-0:mvRYvlHjFAc:gIN9vFwOqvQ)](http://feeds.feedburner.com/~ff/dontesta/blog?a=sW9_qASq1-0:mvRYvlHjFAc:gIN9vFwOqvQ)
 ![](http://feeds.feedburner.com/~r/dontesta/blog/~4/sW9_qASq1-0)