Docker untuk IoT: Containerize Aplikasi Anda

📋 Daftar Isi

Apa Itu Docker?
Instalasi Docker
Images dan Containers
Dockerfile untuk Aplikasi IoT
Docker Compose untuk Stack IoT
Networking di Docker
Volumes dan Persistent Storage
Deploy MQTT Broker di Docker
Docker di Raspberry Pi
Quiz Pemahaman

1. Apa Itu Docker?

Docker adalah platform open-source yang memungkinkan Anda mengemas aplikasi beserta seluruh dependensinya ke dalam satu unit yang disebut container. Container memastikan aplikasi berjalan dengan konsisten di mana saja — di laptop, server cloud, maupun di Raspberry Pi di lokasi terpencil.

Dalam konteks Internet of Things (IoT), Docker memecahkan masalah klasik: "berjalan di mesin saya, tapi tidak di mesin lain." Dengan Docker, Anda bisa mengemas broker MQTT, database, dashboard web, dan skrip sensor ke dalam container terpisah yang bisa di-deploy dan dikelola secara independen.

💡 Mengapa Docker untuk IoT?

Docker menyederhanakan deployment di perangkat IoT yang tersebar di berbagai lokasi. Anda bisa update satu layanan (misalnya broker MQTT) tanpa mengganggu layanan lain. Rollback juga mudah — cukup jalankan versi container sebelumnya. Di Raspberry Pi, Docker memungkinkan Anda menjalankan banyak layanan tanpa konflik dependensi.

Diagram: Perbedaan Container Docker vs Virtual Machine

  ┌─────────────────────────────────┐  ┌─────────────────────────────────┐
  │       VIRTUAL MACHINE           │  │       DOCKER CONTAINER          │
  │                                 │  │                                 │
  │  ┌─────┐ ┌─────┐ ┌─────┐      │  │  ┌─────┐ ┌─────┐ ┌─────┐      │
  │  │App A│ │App B│ │App C│      │  │  │App A│ │App B│ │App C│      │
  │  ├─────┤ ├─────┤ ├─────┤      │  │  ├─────┤ ├─────┤ ├─────┤      │
  │  │Libs │ │Libs │ │Libs │      │  │  │Libs │ │Libs │ │Libs │      │
  │  ├─────┤ ├─────┤ ├─────┤      │  │  └─────┘ └─────┘ └─────┘      │
  │  │Guest│ │Guest│ │Guest│      │  │         │  Docker Engine  │     │
  │  │ OS  │ │ OS  │ │ OS  │      │  │         └────────┬────────┘     │
  │  └─────┘ └─────┘ └─────┘      │  │                  │              │
  │       Hypervisor               │  │            Host OS              │
  │         Host OS                │  │            Hardware              │
  │         Hardware               │  └─────────────────────────────────┘
  └─────────────────────────────────┘
  
  VM: Setiap app punya OS sendiri → Berat (GB), lambat boot
  Docker: Berbagi kernel host → Ringan (MB), instan start

Konsep Dasar Docker

Konsep	Penjelasan	Analogi
Image	Blueprint/template aplikasi yang sudah dikemas	Resep masakan
Container	Instance berjalan dari sebuah image	Masakan yang sudah jadi
Dockerfile	File instruksi untuk membangun image	Langkah-langkah resep
Docker Hub	Registry untuk menyimpan dan berbagi image	Toko buku resep
Volume	Penyimpanan persisten di luar container	Lemari penyimpanan
Network	Jaringan virtual antar container	Jalan penghubung antar rumah

2. Instalasi Docker

Docker tersedia untuk Linux, macOS, dan Windows. Untuk proyek IoT, kita umumnya menginstal Docker di Raspberry Pi (Linux ARM) atau di server pengembangan (Windows/macOS/Linux).

Instalasi di Linux (Ubuntu/Debian/Raspberry Pi OS)

Terminal — Install Docker di Linux

# Update dan install dependensi
sudo apt update
sudo apt install -y ca-certificates curl gnupg

# Tambah Docker GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Tambah repository Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# Tambah user ke grup docker (tanpa sudo)
sudo usermod -aG docker $USER

# Verifikasi instalasi
docker --version
docker compose version

Instalasi di Windows dan macOS

Untuk Windows dan macOS, gunakan Docker Desktop yang sudah termasuk Docker Engine, Docker CLI, dan Docker Compose dalam satu paket.

Kunjungi https://www.docker.com/products/docker-desktop/
Download installer untuk Windows atau macOS
Jalankan installer dan ikuti wizard
Restart komputer setelah instalasi
Buka terminal dan jalankan docker run hello-world untuk verifikasi

⚠️ Catatan untuk Windows

Docker Desktop di Windows memerlukan WSL 2 (Windows Subsystem for Linux) atau Hyper-V. Pastikan fitur WSL 2 sudah diaktifkan. Install WSL 2 dengan menjalankan wsl --install di PowerShell sebagai Administrator.

Terminal — Verifikasi Instalasi

# Jalankan container test
docker run hello-world

# Output jika berhasil:
# Hello from Docker!
# This message shows that your installation appears to be working correctly.

# Cek versi
docker --version
# Docker version 27.x.x, build xxxxxxx

# Cek info sistem Docker
docker info

3. Images dan Containers

Docker Image adalah template read-only yang berisi kode aplikasi, runtime, library, dan konfigurasi. Container adalah instance berjalan dari sebuah image — bisa di-start, stop, restart, dan dihapus.

Perintah Dasar Docker

Terminal — Perintah Docker Dasar

# ===== MANAJEMEN IMAGE =====

# Cari image di Docker Hub
docker search mosquitto

# Pull (download) image dari Docker Hub
docker pull eclipse-mosquitto:2.0

# Lihat semua image yang sudah di-download
docker images

# Hapus image
docker rmi eclipse-mosquitto:2.0

# ===== MANAJEMEN CONTAINER =====

# Jalankan container dari image
docker run -d --name mqtt-broker -p 1883:1883 eclipse-mosquitto:2.0
# -d         = detached (berjalan di background)
# --name     = beri nama container
# -p 1883:1883 = port mapping (host:container)

# Lihat container yang sedang berjalan
docker ps

# Lihat semua container (termasuk yang sudah stop)
docker ps -a

# Lihat log container
docker logs mqtt-broker

# Masuk ke dalam container (shell)
docker exec -it mqtt-broker sh

# Stop container
docker stop mqtt-broker

# Start container yang sudah stop
docker start mqtt-broker

# Hapus container
docker rm mqtt-broker

# Hapus semua container yang sudah stop
docker container prune

Container Lifecycle

Diagram: Lifecycle Container Docker

                    docker create
                         │
                         ▼
                ┌─────────────────┐
                │     Created     │
                └────────┬────────┘
                         │ docker start
                         ▼
                ┌─────────────────┐
                │    Running      │◄──── docker restart
                └───┬────────┬───┘
       docker pause │        │ docker stop / kill
                    ▼        ▼
           ┌──────────┐  ┌──────────┐
           │  Paused   │  │  Stopped │
           └─────┬─────┘  └────┬─────┘
      docker unpause             │
                 │               ▼
                 │      ┌──────────────┐
                 └─────►│   Exited     │
                        └──────────────┘
                              │
                        docker rm (hapus)

ℹ️ Image vs Container

Image = cetak biru (immutable, read-only). Container = instance berjalan dari image (mutable, punya writable layer). Satu image bisa menghasilkan banyak container, seperti satu cetakan kue bisa menghasilkan banyak kue.

4. Dockerfile untuk Aplikasi IoT

Dockerfile adalah file teks berisi instruksi langkah-demi-langkah untuk membangun Docker image. Di proyek IoT, kita biasanya membuat Dockerfile untuk aplikasi sensor reader, data processor, atau web dashboard.

Dockerfile Dasar untuk Aplikasi Python IoT

Dockerfile — Aplikasi MQTT Subscriber IoT

# Gunakan base image Python yang ringan
FROM python:3.11-slim

# Set metadata label
LABEL maintainer="beebane@beebanelabs.id"
LABEL description="MQTT Subscriber untuk IoT"

# Set working directory di dalam container
WORKDIR /app

# Install dependensi (copy requirements.txt dulu untuk caching layer)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy source code ke container
COPY . .

# Set environment variable
ENV MQTT_BROKER=mosquitto
ENV MQTT_PORT=1883
ENV MQTT_TOPIC=iot/sensor/#

# Jalankan aplikasi saat container start
CMD ["python3", "mqtt_subscriber.py"]

File Pendukung

requirements.txt

paho-mqtt==1.6.1
flask==3.0.0
sqlite3-api==2.0.1

Python — mqtt_subscriber.py (contoh aplikasi IoT)

#!/usr/bin/env python3
"""MQTT Subscriber IoT - BeebaneLabs"""
import os
import json
import paho.mqtt.client as mqtt

# Konfigurasi dari environment variable
BROKER = os.getenv("MQTT_BROKER", "localhost")
PORT = int(os.getenv("MQTT_PORT", "1883"))
TOPIC = os.getenv("MQTT_TOPIC", "iot/sensor/#")

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print(f"[OK] Terhubung ke MQTT Broker {BROKER}:{PORT}")
        client.subscribe(TOPIC)
        print(f"[OK] Subscribe ke topic: {TOPIC}")
    else:
        print(f"[ERROR] Gagal terhubung, kode: {rc}")

def on_message(client, userdata, msg):
    try:
        payload = json.loads(msg.payload.decode())
        print(f"[DATA] Topic: {msg.topic} | Data: {json.dumps(payload)}")
    except json.JSONDecodeError:
        print(f"[RAW]  Topic: {msg.topic} | Payload: {msg.payload.decode()}")

if __name__ == "__main__":
    client = mqtt.Client(client_name="iot-docker-subscriber")
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(BROKER, PORT, 60)
    print(f"[START] IoT Subscriber berjalan...")
    client.loop_forever()

Build dan Run Image

Terminal — Build dan Run Docker Image

# Build image dari Dockerfile
docker build -t iot-subscriber:v1.0 .

# Cek image yang sudah dibuat
docker images | grep iot-subscriber

# Jalankan container
docker run -d --name sensor-reader \
  --network iot-network \
  -e MQTT_BROKER=mosquitto \
  -e MQTT_TOPIC="iot/sensor/#" \
  iot-subscriber:v1.0

# Lihat log output
docker logs -f sensor-reader

💡 Tips: Multi-Stage Build untuk Image Lebih Ringan

Gunakan multi-stage build untuk mengurangi ukuran image. Tahap pertama compile dependencies, tahap kedua copy hanya hasilnya. Contoh: base image python:3.11-slim (~150MB) vs python:3.11-alpine (~50MB). Untuk Raspberry Pi dengan storage terbatas, ukuran image sangat penting.

5. Docker Compose untuk Stack IoT

Docker Compose adalah tool untuk mendefinisikan dan menjalankan multiple container sekaligus menggunakan satu file YAML. Ini sangat berguna untuk stack IoT yang terdiri dari broker MQTT, database, subscriber, dan dashboard web.

docker-compose.yml untuk Stack IoT Lengkap

YAML — docker-compose.yml

version: '3.8'

services:
  # ========== MQTT BROKER ==========
  mosquitto:
    image: eclipse-mosquitto:2.0
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883"     # MQTT default port
      - "9001:9001"     # WebSocket port
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    networks:
      - iot-network

  # ========== IoT SUBSCRIBER ==========
  subscriber:
    build: ./subscriber
    container_name: iot-subscriber
    restart: unless-stopped
    environment:
      - MQTT_BROKER=mosquitto
      - MQTT_PORT=1883
      - MQTT_TOPIC=iot/sensor/#
      - DB_PATH=/data/iot_data.db
    volumes:
      - subscriber-data:/data
    depends_on:
      - mosquitto
    networks:
      - iot-network

  # ========== DASHBOARD WEB ==========
  dashboard:
    build: ./dashboard
    container_name: iot-dashboard
    restart: unless-stopped
    ports:
      - "5000:5000"
    environment:
      - MQTT_BROKER=mosquitto
      - DB_PATH=/data/iot_data.db
    volumes:
      - subscriber-data:/data
    depends_on:
      - subscriber
      - mosquitto
    networks:
      - iot-network

  # ========== DATABASE (InfluxDB untuk time-series) ==========
  influxdb:
    image: influxdb:2.7
    container_name: iot-influxdb
    restart: unless-stopped
    ports:
      - "8086:8086"
    volumes:
      - influxdb-data:/var/lib/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=iotpassword123
      - DOCKER_INFLUXDB_INIT_ORG=beebanelabs
      - DOCKER_INFLUXDB_INIT_BUCKET=iot_sensors
    networks:
      - iot-network

# ========== NETWORKS ==========
networks:
  iot-network:
    driver: bridge

# ========== VOLUMES ==========
volumes:
  subscriber-data:
  influxdb-data:

Perintah Docker Compose

Terminal — Docker Compose Commands

# Jalankan semua service di background
docker compose up -d

# Lihat status semua service
docker compose ps

# Lihat log semua service
docker compose logs -f

# Lihat log service tertentu
docker compose logs -f mosquitto

# Stop semua service
docker compose down

# Stop dan hapus volume (HATI-HATI: data hilang!)
docker compose down -v

# Rebuild image setelah perubahan Dockerfile
docker compose up -d --build

# Restart satu service saja
docker compose restart subscriber

# Masuk ke shell container
docker compose exec mosquitto sh

Diagram: Arsitektur Stack IoT dengan Docker Compose

┌────────────────────────────────────────────────────────────────┐
│                    DOCKER COMPOSE STACK                        │
│                                                                │
│  ┌─────────────┐    ┌─────────────┐    ┌──────────────┐      │
│  │  Mosquitto   │    │ Subscriber  │    │  Dashboard   │      │
│  │  (MQTT)      │    │ (Python)    │    │  (Flask)     │      │
│  │  Port 1883   │◄───│             │    │  Port 5000   │      │
│  │              │    │  Proses     │    │              │      │
│  └──────────────┘    │  Data IoT   │    └──────┬───────┘      │
│         ▲            └──────┬──────┘           │              │
│         │                   │                  │              │
│  ┌──────┴───────────────────┴──────────────────┘              │
│  │              iot-network (bridge)                          │
│  └────────────────────────────────────────────────────────────│
│                                                                │
│  ┌──────────────────┐    ┌──────────────────────┐            │
│  │  InfluxDB        │    │  Shared Volumes       │            │
│  │  Port 8086       │    │  - subscriber-data    │            │
│  │  Time-series DB  │    │  - influxdb-data      │            │
│  └──────────────────┘    └──────────────────────┘            │
└────────────────────────────────────────────────────────────────┘

6. Networking di Docker

Docker menyediakan sistem networking virtual yang memungkinkan container berkomunikasi satu sama lain dan dengan dunia luar. Memahami networking sangat penting untuk proyek IoT di mana banyak service saling terhubung.

Jenis-jenis Network di Docker

Jenis Network	Penjelasan	Kapan Digunakan
bridge	Network default, container terisolasi di satu host	Umumnya untuk single-host IoT stack
host	Container langsung menggunakan network host	Butuh performa jaringan maksimal
overlay	Network antar mesin (multi-host)	Swarm cluster di banyak perangkat IoT
macvlan	Container punya IP sendiri di network fisik	IoT device perlu terlihat di LAN
none	Tidak ada networking	Container yang tidak butuh jaringan

Membuat dan Menggunakan Custom Network

Terminal — Docker Network Commands

# Buat custom bridge network untuk IoT
docker network create iot-network

# Lihat semua network
docker network ls

# Inspect detail network
docker network inspect iot-network

# Jalankan container di network tertentu
docker run -d --name mosquitto \
  --network iot-network \
  -p 1883:1883 \
  eclipse-mosquitto:2.0

# Hubungkan container yang sudah ada ke network
docker network connect iot-network my-existing-container

# Putuskan container dari network
docker network disconnect iot-network my-existing-container

# Hapus network
docker network rm iot-network

💡 Service Discovery di Docker

Dalam Docker network, container bisa saling memanggil menggunakan nama container sebagai hostname. Misalnya, container subscriber bisa mengakses broker MQTT di mosquitto:1883 — cukup gunakan nama service dari docker-compose.yml, bukan IP address. Ini mempermudah konfigurasi IoT stack.

7. Volumes dan Persistent Storage

Secara default, data di dalam container akan hilang saat container dihapus. Untuk data IoT yang perlu bertahan (data sensor, konfigurasi, database), kita menggunakan volumes.

Tiga Cara Penyimpanan Data di Docker

Tipe	Lokasi	Kelebihan	Kekurangan
Named Volume	Dikelola Docker (`/var/lib/docker/volumes/`)	Portable, mudah backup	Tidak mudah diedit manual
Bind Mount	Folder di host yang di-mount ke container	Mudah edit langsung	Tergantung path di host
tmpfs	Di RAM saja	Cepat	Hilang saat container stop

Contoh Penggunaan Volume untuk IoT

Terminal — Docker Volume untuk IoT

# ===== NAMED VOLUME =====

# Buat volume untuk data sensor
docker volume create iot-sensor-data

# Lihat semua volume
docker volume ls

# Jalankan container dengan named volume
docker run -d --name subscriber \
  --network iot-network \
  -v iot-sensor-data:/app/data \
  -e MQTT_BROKER=mosquitto \
  iot-subscriber:v1.0

# ===== BIND MOUNT =====

# Mount folder lokal ke container
docker run -d --name mosquitto \
  --network iot-network \
  -p 1883:1883 \
  -v $(pwd)/mosquitto/config:/mosquitto/config \
  -v $(pwd)/mosquitto/data:/mosquitto/data \
  -v $(pwd)/mosquitto/log:/mosquitto/log \
  eclipse-mosquitto:2.0

# ===== INSPECT & BACKUP =====

# Cek detail volume
docker volume inspect iot-sensor-data

# Backup volume ke file tar
docker run --rm \
  -v iot-sensor-data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar czf /backup/iot-data-backup.tar.gz -C /data .

# Restore volume dari backup
docker run --rm \
  -v iot-sensor-data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar xzf /backup/iot-data-backup.tar.gz -C /data

⚠️ Backup Data IoT Secara Rutin

Data sensor IoT sangat berharga — historis suhu, kelembaban, dan pembacaan sensor lainnya. Buat jadwal backup otomatis menggunakan cron job di host yang menjalankan perintah backup volume secara berkala. Jangan hanya mengandalkan satu penyimpanan.

8. Deploy MQTT Broker di Docker

Eclipse Mosquitto adalah broker MQTT open-source yang ringan dan populer untuk IoT. Dengan Docker, Anda bisa meng-deploy Mosquitto dalam hitungan detik dengan konfigurasi yang reproducible.

Struktur Folder

Struktur Proyek Mosquitto Docker

mosquitto-iot/
├── docker-compose.yml
├── mosquitto/
│   ├── config/
│   │   └── mosquitto.conf    ← Konfigurasi broker
│   ├── data/                 ← Data persistence (retain messages)
│   └── log/                  ← Log broker
└── test/
    └── test_mqtt.py          ← Script test koneksi

Konfigurasi Mosquitto

Config — mosquitto.conf

# Mosquitto Configuration untuk IoT
# File: mosquitto/config/mosquitto.conf

# Listener
listener 1883
protocol mqtt

# WebSocket support (untuk dashboard web)
listener 9001
protocol websockets

# Persistence
persistence true
persistence_location /mosquitto/data/

# Logging
log_dest file /mosquitto/log/mosquitto.log
log_type all
connection_messages true
log_timestamp true

# Keamanan (uncomment untuk produksi)
# allow_anonymous false
# password_file /mosquitto/config/passwd

# Performance tuning untuk IoT
max_queued_messages 1000
max_inflight_messages 20

Docker Compose untuk Mosquitto

YAML — docker-compose.yml (Mosquitto saja)

version: '3.8'

services:
  mosquitto:
    image: eclipse-mosquitto:2.0
    container_name: mosquitto-iot
    restart: unless-stopped
    ports:
      - "1883:1883"
      - "9001:9001"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    networks:
      - iot-network
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

networks:
  iot-network:
    driver: bridge

Setup Keamanan MQTT

Terminal — Setup Password Mosquitto

# Buat password file untuk autentikasi
docker exec -it mosquitto-iot mosquitto_passwd \
  -c /mosquitto/config/passwd iotuser

# Tambah user lain
docker exec -it mosquitto-iot mosquitto_passwd \
  /mosquitto/config/passwd sensor_node_1

# Uncomment baris di mosquitto.conf:
# allow_anonymous false
# password_file /mosquitto/config/passwd

# Restart container untuk menerapkan
docker compose restart mosquitto

# Test koneksi dengan autentikasi
mosquitto_sub -h localhost -t "iot/#" \
  -u iotuser -P password_anda

9. Docker di Raspberry Pi

Raspberry Pi adalah platform ideal untuk menjalankan Docker sebagai edge IoT gateway. Dengan ARM processor dan RAM 4-8 GB, Raspberry Pi 4/5 bisa menjalankan beberapa container Docker sekaligus: broker MQTT, subscriber, database, dan dashboard.

⚠️ Gunakan ARM-compatible Images

Raspberry Pi menggunakan prosesor ARM (bukan x86). Pastikan image Docker yang digunakan mendukung arsitektur linux/arm64 atau linux/arm/v7. Image populer seperti eclipse-mosquitto, python, influxdb, dan nginx sudah mendukung ARM. Gunakan Dockerfile dengan base image python:3.11-slim yang otomatis mendukung multi-arch.

Install Docker di Raspberry Pi

Terminal — Install Docker di Raspberry Pi

# Method yang disarankan: Docker convenience script
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Tambah user pi ke grup docker
sudo usermod -aG docker pi

# Logout dan login lagi, lalu verifikasi
docker --version
docker run hello-world

# Cek arsitektur (harus aarch64 untuk Pi 4/5 64-bit)
uname -m
# Output: aarch64

# Cek info Docker
docker info | grep Architecture
# Output: Architecture: aarch64

Optimasi Docker di Raspberry Pi

Terminal — Optimasi Docker untuk Raspberry Pi

# Gunakan alpine image untuk ukuran lebih kecil
# python:3.11-slim ≈ 150MB → python:3.11-alpine ≈ 50MB

# Batasi resource container di Raspberry Pi
docker run -d --name iot-app \
  --memory=256m \
  --cpus=1.0 \
  --restart=unless-stopped \
  iot-app:latest

# Atur di docker-compose.yml:
# services:
#   app:
#     deploy:
#       resources:
#         limits:
#           memory: 256M
#           cpus: '1.0'

# Monitor resource usage
docker stats

# Bersihkan image/container yang tidak dipakai
docker system prune -a --volumes

# Cek penggunaan disk Docker
docker system df

Contoh Stack IoT Lengkap di Raspberry Pi

YAML — docker-compose.yml untuk Raspberry Pi IoT

version: '3.8'

services:
  mosquitto:
    image: eclipse-mosquitto:2.0
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    networks:
      - iot-net
    deploy:
      resources:
        limits:
          memory: 128M

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
    networks:
      - iot-net
    depends_on:
      - mosquitto
    deploy:
      resources:
        limits:
          memory: 512M

  influxdb:
    image: influxdb:2.7
    container_name: influxdb
    restart: unless-stopped
    ports:
      - "8086:8086"
    volumes:
      - influxdb-data:/var/lib/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=iotpass123
      - DOCKER_INFLUXDB_INIT_ORG=beebanelabs
      - DOCKER_INFLUXDB_INIT_BUCKET=sensors
    networks:
      - iot-net
    deploy:
      resources:
        limits:
          memory: 512M

networks:
  iot-net:
    driver: bridge

volumes:
  grafana-data:
  influxdb-data:

💡 Tips Raspberry Pi Docker

Gunakan USB SSD sebagai storage Docker untuk performa lebih baik daripada microSD. Mount Docker data root ke SSD dengan mengedit /etc/docker/daemon.json → {"data-root": "/mnt/ssd/docker"}



      
      
        
      

      
      
      
      10. Quiz: Uji Pemahamanmu!
      Setelah membaca tutorial di atas, jawablah 5 pertanyaan berikut untuk menguji pemahamanmu tentang Docker untuk IoT:

      

        
        
          Pertanyaan 1: Apa perbedaan utama antara Docker Container dan Virtual Machine?
          
            a) Container berbagi kernel host, VM memiliki OS sendiri
            b) Container lebih berat daripada VM
            c) VM tidak bisa menjalankan Linux
            d) Container hanya bisa dijalankan di Windows
          
        

        
        
          Pertanyaan 2: Perintah Docker mana yang benar untuk menjalankan container di background?
          
            a) docker run -it nginx
            b) docker run -d nginx
            c) docker start -b nginx
            d) docker launch nginx
          
        

        
        
          Pertanyaan 3: Mengapa data hilang saat container dihapus?
          
            a) Karena Docker tidak mendukung penyimpanan
            b) Karena container layer bersifat sementara, perlu volume untuk persistensi
            c) Karena container hanya berjalan di RAM
            d) Karena Docker menggunakan enkripsi yang menghapus data
          
        

        
        
          Pertanyaan 4: Di Docker network bridge, container A bisa mengakses container B menggunakan apa?
          
            a) IP address host
            b) Nama container/service sebagai hostname
            c) MAC address container
            d) Port number container
          
        

        
        
          Pertanyaan 5: Mengapa harus menggunakan image ARM-compatible saat deploy Docker di Raspberry Pi?
          
            a) Karena Raspberry Pi hanya menjalankan Windows
            b) Karena Raspberry Pi menggunakan prosesor ARM, bukan x86/x64
            c) Karena Raspberry Pi tidak mendukung Docker
            d) Karena image ARM lebih cepat daripada image x86
          
        

        
        
      

      
      
        
      

      
      
      
      
        
          ← Sebelumnya
          Raspberry Pi untuk IoT
        
        
          Selanjutnya →
          Firebase untuk IoT