Hur installerar man Mosquitto MQTT-broker med Docker Compose

I den här artikeln kommer vi att titta på hur man installerar en Mosquitto MQTT-broker med hjälp av Docker Compose. MQTT (Message Queuing Telemetry Transport) är ett lättviktsprotokoll för meddelandehantering som används ofta inom IoT (Internet of Things). Mosquitto är en av de mest populära implementeringarna av detta protokoll och erbjuder en robust och effektiv lösning för att hantera meddelanden mellan IoT-enheter.

Att använda Docker gör det enkelt att distribuera och hantera applikationer i containrar. Med Mosquitto Docker kan du snabbt starta en MQTT-broker utan att behöva installera programvara på ditt system. I denna tutorial kommer vi att gå igenom steg-för-steg hur du installerar och konfigurerar Mosquitto MQTT-brokern med hjälp av Docker Compose för att skapa en komplett och fungerande meddelandestyrningstjänst.

Innan vi dyker in i installationsprocessen är det viktigt att förstå vad Mosquitto och MQTT egentligen är, samt vilka förutsättningar som krävs för att genomföra installationen. Vi kommer också att gå igenom installationsvite för Docker, vilket är en kritisk komponent i denna tutorial.

Vad är Mosquitto och MQTT?

Mosquitto är en populär, öppen källkodsimplementation av MQTT protokollet. Den är designad för att vara lättviktig och enkel att använda, vilket gör den idealisk för IoT-miljöer. MQTT är ett pub/sub-meddelandeprotokoll som är byggt för anslutna enheter. Det gör det möjligt för enheter att kommunicera med varandra genom att skicka meddelanden till en central server, som i detta fall är Mosquitto broker.

MQTT har flera fördelar, inklusive låg bandbreddsanvändning och realtidskommunikation. Det är därför det har blivit det föredragna valet för många utvecklare i IoT-världen. Med Mosquitto MQTT broker kan användaren enkelt publicera och prenumerera på meddelanden, vilket gör det möjligt för olika enheter att utbyta data på ett effektivt sätt.

Förutsättningar

Innan vi kan börja installera Mosquitto MQTT-brokern med Docker Compose, behöver vi säkerställa att vi har rätt förutsättningar. Här är vad du behöver för att komma igång:

• En server eller dator med Linux som operativsystem (vi kommer att använda Ubuntu i detta exempel).
• Installationen av Docker och Docker Compose.
• Grundläggande kunskaper om terminalkommando och systemadministration.

Installera Docker

För att kunna använda Mosquitto Docker måste vi först installera Docker på vårt system. Docker erbjuder en plattform för att skapa, hantera och isolera applikationer i containrar. Följ stegen nedan för att installera Docker:

1. Uppdatera ditt system:

  sudo apt-get update
  sudo apt-get upgrade
  

2. Installera nödvändiga paket för att tillåta apt att använda ett repository över HTTPS:

  sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
  

3. Lägg till Dockers officiella GPG-nyckel:

  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
  

4. Lägg till Docker-repository:

  sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
  

5. Installera Docker:

  sudo apt-get update
  sudo apt-get install docker-ce
  

När installationen är klar kan du kontrollera att Docker fungerar genom att köra följande kommando:

  
sudo docker --version

Förbereda systemet

Innan vi kan börja med Mosquitto installationen, måste vi också installera Docker Compose. Denna applikation gör det möjligt för oss att definiera och köra multi-container Docker-applikationer.

1. Installera Docker Compose genom att ladda ner den senaste versionen:

  sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  

2. Ge körbehörigheter till Docker Compose:

  sudo chmod +x /usr/local/bin/docker-compose
  

3. Kontrollera installationen:

  docker-compose --version
  

Skriva Docker Compose-fil

Nu när både Docker och Docker Compose är installerade kan vi skriva vår Docker Compose-fil. Denna fil beskriver hur vår Mosquitto MQTT-broker ska köras i en Docker-container. Skapa en ny fil med namnet docker-compose.yml:

nano docker-compose.yml

Fyll i filen med följande innehåll:

version: '3.8'

services:
  mosquitto:
    image: eclipse-mosquitto:latest
    ports:
      - "1883:1883"   # MQTT
      - "9001:9001"   # WebSocket
    volumes:
      - mosquitto_data:/mosquitto/data
      - mosquitto_config:/mosquitto/config
    restart: unless-stopped

volumes:
  mosquitto_data:
  mosquitto_config:

I denna fil definierar vi en tjänst som heter mosquitto, som kommer att använda den senaste versionen av eclipse-mosquitto-avbildningen. Vi exponerar portarna 1883 (för MQTT) och 9001 (för WebSocket), och vi definierar volymer för att spara data och konfigurationer.

Konfigurera Mosquitto med en konfigurationsfil

För att anpassa inställningarna för vår Mosquitto MQTT-broker behöver vi skapa en konfigurationsfil. Skapa en ny fil med namnet mosquitto.conf under en konfigurationsvolym som vi refererade till i vår Docker Compose-fil:

nano mosquitto.conf

Lägg till följande innehåll:

listener 1883
protocol mqtt

listener 9001
protocol websockets

Denna konfigurationsfil definierar två lyssnare: en för MQTT på port 1883 och en för WebSocket på port 9001. När du har sparat filen, se till att den är kopplad till vårt Docker-kontainer genom att definiera dess plats i docker-compose.yml:

    volumes:
      - mosquitto_data:/mosquitto/data
      - ./mosquitto.conf:/mosquitto/config/mosquitto.conf

Skapa en användardatabas för autentisering

För att säkra vår Mosquitto MQTT-broker kan vi också anpassa autentisering. Vi kan skapa en användardatabas för att kontrollera vilka användare som får skicka och ta emot meddelanden. För att göra detta skapar vi en fil som heter passwordfile.txt:

nano passwordfile.txt

Lägg till användarnamn och lösenord med följande syntax.:

user1:$(mosquitto_passwd -b passwordfile.txt user1 password1)
user2:$(mosquitto_passwd -b passwordfile.txt user2 password2)

När du har skapat användardatabasen, dubblera koppla den i docker-compose.yml genom att definiera dess plats som en volym:

    volumes:
      - ./passwordfile.txt:/mosquitto/config/passwordfile.txt

I vår mosquitto.conf måste vi också lägga till följande rad för att aktivera autentisering:

password_file /mosquitto/config/passwordfile.txt

Starta Mosquitto MQTT-broker

Nu när vi har konfigurerat vår Mosquitto MQTT-broker är det dags att starta den. Du kan göra detta genom att köra följande kommando:

docker-compose up -d

Flaggan -d betyder att vi kör dockern i bakgrunden. För att se loggarna kan du använda kommandot:

docker-compose logs -f

Skicka och ta emot meddelanden

Nu när vår MQTT-broker körs kan vi börja skicka och ta emot meddelanden. För att göra detta kan vi använda olika klienter. En populär val är MQTT.fx eller även mosquitto_pub och mosquitto_sub kommandon.

För att publicera ett meddelande kan du använda följande kommando:

docker exec -it [container_name] mosquitto_pub -h localhost -t 'test/topic' -m 'Hello MQTT'

För att prenumerera på ämnet kan du använda:

docker exec -it [container_name] mosquitto_sub -h localhost -t 'test/topic'

Uppdatera Mosquitto-brokern

Det är viktigt att hålla vår Mosquitto MQTT-broker uppdaterad, särskilt för säkerhetens skull. För att uppdatera Mosquitto Docker bilden, kan vi använda följande kommando:

docker-compose pull

Detta kommando drar den senaste bilden. För att sedan starta om våra tjänster för att använda den senaste bilden, kör:

docker-compose up -d

Sammanfattning

I den här tutorialen har vi gått igenom hur man installerar en Mosquitto MQTT-broker med hjälp av Docker Compose. Vi har lärt oss om MQTT-protokollet och hur Mosquitto fungerar i samband med detta. Genom att följa stegen för att installera Docker, skapa en Docker Compose-fil, konfigurera Mosquitto och sätta upp autentisering, har vi byggt en funktionell MQTT-broker. Genom att använda mqtt docker kan vi enkelt arbeta med och skala vår meddelandebroker och möjliggöra effektiv kommunikation mellan IoT-enheter.

Vi har också fått en insikt i hur man hanterar och uppdaterar Mosquitto Docker bilden för att säkerställa att vi alltid har den senaste och mest säkra versionen av vår broker. Genom att implementera dessa verktyg möjliggör vi att skapa robusta och effektiva IoT-lösningar som kan kommunicera smidigt med varandra.

Tack för att du läste vår artikel, du kan se alla artiklar i våra webbkartor eller i Sitemaps

Tyckte du att den här artikeln var användbar? Hur installerar man Mosquitto MQTT-broker med Docker Compose Du kan se mer här NanoPi.