物联网核心队列配置教程：使用AWS GoLang SDK 版本 2

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《物联网核心队列配置教程：使用AWS GoLang SDK 版本 2》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

我正在尝试使用 aws golang sdk 版本 2 (https://github.com/aws/aws-sdk-go-v2) 为 linux 设备实施队列配置。

我编写了以下代码，成功创建了通用声明凭据。现在，我想实现设备上发生的队列配置流程，以将通用声明交换为每个设备的唯一凭据。该流程如此处的 aws python sdk 示例所示 --> https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/fleetprovisioning.py

python 示例使用 mqtt 完成工作。看起来它使用通用声明连接到 iot core 端点，然后调用“createkeysandcertificate”和“registerthing”。到目前为止，我不知道如何使用 golang sdk 完成同样的事情。有一个 registerthing 函数，但我不确定如何与 golang 中的通用声明“连接”，以便调用“createkeysandcertificate”。如何使用 golang sdk 完成此任务？

log.Println(color.InBlue("Creating AWS fleet provisioning generic claims ..."))

    // Load the Shared AWS Configuration (~/.aws/config)
    log.Println(color.InBlue("Loading AWS configuration file now ..."))
    cfg, cfgErr := config.LoadDefaultConfig(context.TODO(), config.WithSharedCredentialsFiles(
        []string{"config"},
    ))
    if cfgErr != nil {
        log.Fatal(color.InRed("Error: Failed to get configuration: "), cfgErr.Error())
    } else {
        log.Println(color.InGreen("Successfully read configuration ..."))
    }

    // Create an Amazon S3 service client
    client := iot.NewFromConfig(cfg)
    log.Println(color.InGreen("Successfully created AWS iot client ..."))

    // Create the thing group $THING_GROUP_NAME. Device created by fleet provisioning will be added to this group.
    // e.g. --> aws iot create-thing-group --thing-group-name $THING_GROUP_NAME
    createThingGroupParams := iot.CreateThingGroupInput{
        ThingGroupName:       aws.String(THING_GROUP_NAME),
        ParentGroupName:      nil,
        Tags:                 nil,
        ThingGroupProperties: nil,
    }

    createThingGroupOutput, createThingGroupErr := client.CreateThingGroup(context.TODO(), &createThingGroupParams)
    if createThingGroupErr != nil {
        log.Fatal(color.InRed("Error: Failed to create ThingGroup: "), createThingGroupErr.Error())
    } else {
        log.Println(color.InGreen("Create ThingGroup returned: "), createThingGroupOutput)
    }

    // Create the provisioning template
    jsonProvisioningTemplateString, jsonProvisioningTemplateErr := readJsonFileIntoString(FLEET_PROVISIONING_TEMPLATE)
    if jsonProvisioningTemplateErr != nil {
        log.Fatal(color.InRed("Error: Failed to get FleetProvisioningTemplate: "), jsonProvisioningTemplateErr.Error())
    } else {
        log.Println(color.InGreen("Successfully read FleetProvisioningTemplate: "), jsonProvisioningTemplateString)
    }
    createProvisioningTemplateParams := iot.CreateProvisioningTemplateInput{
        ProvisioningRoleArn: aws.String(ARN_IOT_PROVISIONING_ROLE),
        TemplateBody:        aws.String(jsonProvisioningTemplateString),
        TemplateName:        aws.String(FLEET_PROVISIONING_TEMPLATE_NAME),
        Description:         nil,
        Enabled:             true,
        PreProvisioningHook: nil,
        Tags:                nil,
        Type:                "",
    }

    createProvisioningTemplateOutput, createProvisioningTemplateErr := client.CreateProvisioningTemplate(context.TODO(), &createProvisioningTemplateParams)
    if createProvisioningTemplateErr != nil {
        log.Fatal(color.InRed("Error: Failed to create ProvisioningTemplate: "), createProvisioningTemplateErr.Error())
    } else {
        log.Println(color.InGreen("Create ProvisioningTemplate returned: "), createProvisioningTemplateOutput)
    }

    // Read back the template for proof
    describeProvisioningTemplateParams := iot.DescribeProvisioningTemplateInput{TemplateName: aws.String(FLEET_PROVISIONING_TEMPLATE_NAME)}
    describeProvisioningTemplateOutput, describeProvisioningTemplateErr := client.DescribeProvisioningTemplate(context.TODO(), &describeProvisioningTemplateParams)
    if describeProvisioningTemplateErr != nil {
        log.Fatal(color.InRed("Error: Failed to get Description of ProvisioningTemplate: "), describeProvisioningTemplateErr.Error())
    } else {
        log.Println(color.InGreen("Description of ProvisioningTemplate returned: "), describeProvisioningTemplateOutput)
    }

    // Create the claim certificate and key
    createKeysAndCertificateParams := iot.CreateKeysAndCertificateInput{SetAsActive: true}
    createKeysAndCertsOutput, createKeysAndCertsErr := client.CreateKeysAndCertificate(context.TODO(), &createKeysAndCertificateParams)
    if createKeysAndCertsErr != nil {
        log.Fatal(color.InRed("Error: Failed to Create KeysAndCertificate: "), createKeysAndCertsErr.Error())
    } else {
        log.Println(color.InGreen("Successfully Created KeysAndCertificate: "), createKeysAndCertsOutput)
    }

    // Get the certificate arn from the result of the previous command. The certificate arn is required to attach an IoT policy to it
    jsonPolicyString, jsonPolicyErr := readJsonFileIntoString(FLEET_PROVISIONING_POLICY)
    if jsonPolicyErr != nil {
        log.Fatal(color.InRed("Error: Failed to get Policy: "), jsonPolicyErr.Error())
    } else {
        log.Println(color.InGreen("Successfully read Policy: "), jsonPolicyString)
    }
    createPolicyParams := iot.CreatePolicyInput{
        PolicyDocument: aws.String(jsonPolicyString),
        PolicyName:     aws.String(FLEET_PROVISIONING_POLICY_NAME),
        Tags:           nil,
    }

    // Create the policy
    createPolicyOutput, createPolicyErr := client.CreatePolicy(context.TODO(), &createPolicyParams)
    if createPolicyErr != nil {
        log.Fatal(color.InRed("Error: Failed to Create Policy: "), createPolicyErr.Error())
    } else {
        log.Println(color.InGreen("Successfully Created Policy: "), createPolicyOutput)
    }

    // Attach the policy
    attachPolicyParams := iot.AttachPolicyInput{
        PolicyName: aws.String(FLEET_PROVISIONING_POLICY_NAME),
        Target:     createKeysAndCertsOutput.CertificateArn,
    }

    attachPolicyOutput, attachPolicyErr := client.AttachPolicy(context.TODO(), &attachPolicyParams)
    if attachPolicyErr != nil {
        log.Fatal(color.InRed("Error: Failed to Attach Policy: "), attachPolicyErr.Error())
    } else {
        log.Println(color.InGreen("Successfully Attach Policy: "), attachPolicyOutput)
    }

    // If all is well, saved the claims ( generic ) certificate and public/private keys.
    privKeyErr := writeJsonStringIntoFile(FLEET_PROVISIONING_GENERIC_CLAIM_PRIVATE, *createKeysAndCertsOutput.KeyPair.PrivateKey)
    if privKeyErr != nil {
        log.Fatal(color.InRed("Error: Failed to save Private Key: "), privKeyErr.Error())
    }

    pubKeyErr := writeJsonStringIntoFile(FLEET_PROVISIONING_GENERIC_CLAIM_PUBLIC, *createKeysAndCertsOutput.KeyPair.PublicKey)
    if pubKeyErr != nil {
        log.Fatal(color.InRed("Error: Failed to save Public Key: "), pubKeyErr.Error())
    }

    cerErr := writeJsonStringIntoFile(FLEET_PROVISIONING_GENERIC_CLAIM_CERT, *createKeysAndCertsOutput.CertificatePem)
    if cerErr != nil {
        log.Fatal(color.InRed("Error: Failed to save Certificate Key: "), cerErr.Error())
    }

    log.Println(color.InGreen("Success!"))

正确答案

您提到的 python 脚本正在利用队列配置过程。 python 脚本使用声明凭据进行连接，然后发布到特定主题以接收最终证书。

我建议看看这篇博文：https://aws.amazon.com/blogs/iot/how-to-automate-onboarding-of-iot-devices-to-aws-iot-core-at-scale-with-fleet-provisioning/ 它解释了流程。

队列配置适用于您定义的模板。然后您必须进行 mqtt 调用才能注册您的设备。队列配置将负责在 AWS IoT 中创建事物以及创建证书并附加您定义的策略。

另外，请查看详细文档。它描述了您必须发送才能使用 AWS IoT 队列预配置的不同 MQTT 消息。 https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html

到这里，我们也就讲完了《物联网核心队列配置教程：使用AWS GoLang SDK 版本 2》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！