How Working with Mosquitto Helped Me Grow as a Developer - A Journey into IoT Communication

Shams Pathan — Tue, 13 May 2025 08:51:27 +0000

A Journey into IoT Communication, MQTT, and Secure Messaging

When I first stumbled upon Mosquitto, I didn’t expect it would take me so deep into the world of IoT systems, real-time communication, and developer growth. What started as an experiment with lightweight messaging evolved into a journey of architectural insight and security design.

🌐 Why I Chose Mosquitto

Any IoT system depends on efficient communication—small packets, low latency, and resilience across unreliable networks.

That’s exactly where MQTT (Message Queuing Telemetry Transport) comes in. It’s a lightweight pub/sub protocol designed for constrained devices. And Mosquitto? It's a fast, open-source MQTT broker with a strong community—perfect for learning and deploying real-world systems.

🛠️ Setting Up Mosquitto

On my Debian Linux setup, getting started was as simple as:

sudo apt update
sudo apt install mosquitto mosquitto-clients
sudo systemctl start mosquitto

Boom. The broker was running, ready to handle device messages.

🔄 Connecting IoT Devices via MQTT

One of the most powerful aspects of MQTT is its publish/subscribe model. Instead of tightly coupling devices, they communicate via topics.

Example use-case:

A temperature sensor publishes to: home/livingroom/temperature
A mobile app subscribes to that topic to display live data
A smart fan also subscribes and activates when temperature exceeds a threshold

Using CLI tools:

mosquitto_pub -t home/livingroom/temperature -m "27.3"
mosquitto_sub -t home/livingroom/temperature

Just like that—I could see real-time messages flow. 💡

🔐 Securing It with `mosquitto-go-auth`

As things scaled, I needed authentication and access control. That’s when I discovered mosquitto-go-auth, a flexible plugin that integrates with various backends to manage users and ACLs.

✅ Supported Backends:

MySQL / PostgreSQL
Redis
MongoDB
JWT
HTTP
YAML/JSON files

I went with MySQL. Here's what I did:

🔧 Integration Steps

1. Enable Plugin in `mosquitto.conf`:

auth_plugin /etc/mosquitto/go-auth/go-auth.so
auth_plugin_opt_backends mysql
auth_plugin_opt_mysql_host localhost
auth_plugin_opt_mysql_port 3306
auth_plugin_opt_mysql_user mqtt_user
auth_plugin_opt_mysql_password mqtt_pass
auth_plugin_opt_mysql_db mqtt

2. MySQL Tables for Users and ACL:

CREATE TABLE mqtt_user (
  username VARCHAR(100),
  password VARCHAR(100),
  salt VARCHAR(100)
);

CREATE TABLE mqtt_acl (
  username VARCHAR(100),
  topic VARCHAR(100),
  acc INT
);

3. Sample ACLs:

-- Write access for sensor
INSERT INTO mqtt_acl (username, topic, acc) VALUES ('sensor1', 'home/sensor1/data', 2);

-- Read access for dashboard
INSERT INTO mqtt_acl (username, topic, acc) VALUES ('dashboard', 'home/+/data', 1);

Access flags:

1 → Read
2 → Write
3 → Read + Write

🧠 Lessons Learned

🌟 Pub/Sub over HTTP: MQTT’s decoupled model is more powerful than I imagined.
🔐 Security is non-optional: Real deployments need real auth.
📊 Observability is key: Real-time debugging and logs matter.
🧱 Protocols matter: Understanding low-level data flow makes you a better developer.

🧩 Final Thoughts

From quick tests to full-featured secure deployments, working with Mosquitto and mosquitto-go-auth taught me a lot about:

Event-driven systems
Lightweight protocol design
Practical backend integration

If you're building IoT, real-time systems, or even internal service communication—start with Mosquitto. Learn MQTT. Understand how auth works. You’ll grow as a developer, trust me.

🛠️ Bonus

Want config samples or a GitHub repo?

Drop a comment or message me—I’d love to share what I’ve built.

Why You Can’t Access Struct Fields Through Interfaces in Go (and How to Fix It)

Shams Pathan — Tue, 15 Apr 2025 21:15:44 +0000

Ever written something like this in Go?

var a Animal = Dog{Name: "Charlie"}
fmt.Println(a.Name) // 💥 compile-time error

...and thought, “Wait — why can’t I access Name when it’s clearly part of the struct?”

🔍 Why This Happens

In Go, interfaces are contracts, not containers for struct fields. They only guarantee access to methods, not fields. So when you assign a struct to an interface, Go stores it as a hidden value — only accessible if you:

Know the underlying type
Use type assertion, or
Use reflection

🧪 Real-World Example: API Payload

Let’s say you’re writing an API handler that receives some payload:

type User struct {
    Name  string
    Email string
}

func (u User) IsValid() bool {
    return u.Email != ""
}

type Payload interface {
    IsValid() bool
}

Now in your handler:

func Handle(p Payload) {
    fmt.Println(p.IsValid()) // ✅ fine
    fmt.Println(p.Name)      // ❌ compile error
}

Yep — Go won’t let you access p.Name. Because Payload doesn’t know Name exists.

✅ Solution: Type Assertion

You can safely access the struct’s fields if you assert its type:

if u, ok := p.(User); ok {
    fmt.Println(u.Name) // 🎯 works!
}

Or if you’re not sure of the type, use a type switch:

switch v := p.(type) {
case User:
    fmt.Println(v.Name)
default:
    fmt.Println("Unknown type")
}

⚠️ Or... Use Reflection (Carefully)

You can also access struct fields dynamically via reflect, like:

val := reflect.ValueOf(p)
field := val.FieldByName("Name")
fmt.Println(field.String())

But reflection can be tricky and error-prone. Use it only when you can’t use static typing — like dynamic JSON decoding or generic form handlers.

✨ Conclusion

Go’s strict typing can feel limiting at first, but it protects you from a whole class of bugs. Once you understand interfaces don’t “carry” struct fields — just methods — it all starts to click.

Want to go deeper? I shared the full breakdown with code samples and reflection examples here:

👉 Read the full post on Medium

Have you ever hit this issue in a real project? How did you work around it? Let’s chat below 👇

go #programming #backend #interfaces #reflection

DEV Community: Shams Pathan