Golang实现Google IoT Core设备连接的物联网框架插件

Google IoT Core是Google Cloud提供的物联网设备管理平台，下面我将介绍如何使用Golang实现设备连接Google IoT Core的框架插件。

准备工作

1. 在Google Cloud Console中创建IoT Core注册表
2. 创建设备并生成密钥对（RSA或EC）
3. 启用必要的Google Cloud API

核心代码实现

1. 设备认证连接

package iotcore

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"io/ioutil"
	"time"

	mqtt "github.com/eclipse/paho.mqtt.golang"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/cloudiot/v1"
)

// DeviceConfig 设备配置
type DeviceConfig struct {
	ProjectID  string
	Region     string
	RegistryID string
	DeviceID   string
	PrivateKey []byte
	Algorithm  string // "RS256" 或 "ES256"
}

// Connect 连接到Google IoT Core
func (d *DeviceConfig) Connect() (mqtt.Client, error) {
	// 创建JWT token
	token, err := d.createJWT()
	if err != nil {
		return nil, fmt.Errorf("failed to create JWT: %v", err)
	}

	// MQTT配置
	broker := fmt.Sprintf("ssl://mqtt.googleapis.com:8883")
	clientID := fmt.Sprintf("projects/%s/locations/%s/registries/%s/devices/%s",
		d.ProjectID, d.Region, d.RegistryID, d.DeviceID)

	opts := mqtt.NewClientOptions()
	opts.AddBroker(broker)
	opts.SetClientID(clientID)
	opts.SetUsername("unused") // 用户名必须设置但不会被使用
	opts.SetPassword(token)    // 密码设置为JWT token

	// TLS配置
	certpool := x509.NewCertPool()
	pemCerts, err := ioutil.ReadFile("roots.pem") // Google根证书
	if err == nil {
		certpool.AppendCertsFromPEM(pemCerts)
	}

	opts.SetTLSConfig(&tls.Config{
		RootCAs:            certpool,
		ClientAuth:         tls.NoClientCert,
		InsecureSkipVerify: true,
	})

	client := mqtt.NewClient(opts)
	if token := client.Connect(); token.Wait() && token.Error() != nil {
		return nil, fmt.Errorf("failed to connect: %v", token.Error())
	}

	return client, nil
}

// createJWT 创建JWT token
func (d *DeviceConfig) createJWT() (string, error) {
	conf := &jwt.Config{
		PrivateKey: d.PrivateKey,
		Algorithm:  d.Algorithm,
		TokenExp:   24 * time.Hour,
		Audience:   d.ProjectID,
	}
	return conf.Create()
}

2. 设备管理

// DeviceManager 设备管理
type DeviceManager struct {
	service *cloudiot.Service
}

// NewDeviceManager 创建设备管理器
func NewDeviceManager(credentialsFile string) (*DeviceManager, error) {
	ctx := context.Background()
	
	data, err := ioutil.ReadFile(credentialsFile)
	if err != nil {
		return nil, fmt.Errorf("failed to read credentials: %v", err)
	}

	config, err := google.JWTConfigFromJSON(data, cloudiot.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("failed to create JWT config: %v", err)
	}

	service, err := cloudiot.New(config.Client(ctx))
	if err != nil {
		return nil, fmt.Errorf("failed to create IoT service: %v", err)
	}

	return &DeviceManager{service: service}, nil
}

// CreateDevice 创建设备
func (dm *DeviceManager) CreateDevice(projectID, region, registryID, deviceID string, publicKey []byte) error {
	parent := fmt.Sprintf("projects/%s/locations/%s/registries/%s", projectID, region, registryID)
	
	device := &cloudiot.Device{
		Id: deviceID,
		Credentials: []*cloudiot.DeviceCredential{
			{
				PublicKey: &cloudiot.PublicKeyCredential{
					Format: "RSA_X509_PEM",
					Key:    string(publicKey),
				},
			},
		},
	}

	_, err := dm.service.Projects.Locations.Registries.Devices.Create(parent, device).Do()
	return err
}

3. 消息发布与订阅

// Publish 发布消息
func Publish(client mqtt.Client, topic string, payload []byte) error {
	token := client.Publish(topic, 1, false, payload)
	token.Wait()
	return token.Error()
}

// Subscribe 订阅主题
func Subscribe(client mqtt.Client, topic string, callback mqtt.MessageHandler) error {
	token := client.Subscribe(topic, 1, callback)
	token.Wait()
	return token.Error()
}

使用示例

func main() {
	// 1. 初始化设备配置
	config := &iotcore.DeviceConfig{
		ProjectID:  "your-project-id",
		Region:     "us-central1",
		RegistryID: "your-registry",
		DeviceID:   "device-001",
		PrivateKey: []byte("-----BEGIN RSA PRIVATE KEY-----\n..."),
		Algorithm:  "RS256",
	}

	// 2. 连接设备
	client, err := config.Connect()
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer client.Disconnect(250)

	// 3. 订阅配置更新
	err = iotcore.Subscribe(client, "/devices/device-001/config", func(c mqtt.Client, m mqtt.Message) {
		log.Printf("Received config: %s", m.Payload())
	})
	if err != nil {
		log.Printf("Failed to subscribe: %v", err)
	}

	// 4. 发布遥测数据
	for {
		data := fmt.Sprintf(`{"temp": %.1f, "humidity": %.1f}`, 25.5, 60.2)
		err := iotcore.Publish(client, "/devices/device-001/events", []byte(data))
		if err != nil {
			log.Printf("Failed to publish: %v", err)
		}
		time.Sleep(10 * time.Second)
	}
}

最佳实践

1. 错误处理：实现重试逻辑处理连接中断
2. 安全：定期轮换设备密钥
3. 资源管理：合理设置QoS级别（通常遥测数据用QoS1，配置更新用QoS0）
4. 日志记录：记录设备连接状态和消息传输情况
5. 资源清理：确保设备断开连接时释放资源

总结

这个框架提供了Google IoT Core设备连接的基本功能，包括：

• 使用JWT进行设备认证
• MQTT协议通信
• 设备管理API
• 消息发布/订阅

你可以在此基础上扩展更多功能，如设备影子、OTA更新等。