使用MQTT将iOS设备连接到AWS IoT的最佳方式？

Question

I have built an ipad app which i connect to a sensorTag, which is sending temperature data to the app.

What I would like to do is to send the temperature data to AWS IoT, the idea was to use MQTT. I have set up a local server to which I send test data to AWS IoT, but I don't manage to connect the device to the same endpoint. I think the reason for this is that the local server can publish data because it refers to the certificate and the private key. But in xcode I don't know how to do that, so without certificate and private key reference I don't think the iOS app can connect to IoT. Is this correct?

What would be the best way to go from here? I downloaded the AWS iOS SDK, but it doesn't seems to support IoT.

I was thinking that I maybe can let the iOS app send its data to a external server which has the certificate and the key connected to itself, and then let the server publish the data over to AWS IoT.

Answer 1

The AWS iOS SDK has been updated with support for AWS IoT. You can now interact with the control API as well as establish connections to the platform and perform publish and subscribe actions.

SDK home: https://aws.amazon.com/documentation/sdk-for-ios/

Pub/sub interface: http://docs.aws.amazon.com/AWSiOSSDK/latest/Classes/AWSIoTDataManager.html

Sample: https://github.com/awslabs/aws-sdk-ios-samples/tree/master/IoT-Sample/Swift/

Besides that, you can also create your certificate and policy in AWS IoT and plug your certificate keys in to a TLS-compliant MQTT client for iOS. There are a few on GitHub.

Answer 2

No, you can not able to connect without certificate. The best approach is write a function to connect with aws iot in appdelegate save iot manager and iot datamanger object in userdefault. when you launch app check with object, get connection status, if not connected then try to connect again.

first initialize

func initalizeAWS(){
    // Initialize AWSMobileClient for authorization
    AWSMobileClient.sharedInstance().initialize { (userState, error) in
        guard error == nil else {
            print("Failed to initialize AWSMobileClient. Error: \(error!.localizedDescription)")
            return
        }
        print("AWSMobileClient initialized.")
    }
    // Init IOT
    let iotEndPoint = AWSEndpoint(urlString: IOT_ENDPOINT)

    // Configuration for AWSIoT control plane APIs
    let iotConfiguration = AWSServiceConfiguration(region: AWSRegion, credentialsProvider: AWSMobileClient.sharedInstance())

    // Configuration for AWSIoT data plane APIs
    let iotDataConfiguration = AWSServiceConfiguration(region: AWSRegion,
                                                       endpoint: iotEndPoint,
                                                       credentialsProvider: AWSMobileClient.sharedInstance())
    AWSServiceManager.default().defaultServiceConfiguration = iotConfiguration

    iotManager = AWSIoTManager.default()
    iot = AWSIoT.default()

    AWSIoTDataManager.register(with: iotDataConfiguration!, forKey: ASWIoTDataManager)
    iotDataManager = AWSIoTDataManager(forKey: ASWIoTDataManager)
}

Connect to AWS IOT

func connectToAWS(){

    func mqttEventCallback( _ status: AWSIoTMQTTStatus )
    {
        DispatchQueue.main.async {
            print("connection status = \(status.rawValue)")
            switch(status)
            {
            case .connecting:

                print( "Connecting..." )

            case .connected:
                self.connected = true
                let defaults = UserDefaults.standard
                let certificateId = defaults.string( forKey: "certificateId")
                print(certificateId)
                print( "Connected." )
                //subscribe for topic when connected
                    self.subscribe(topic: topic)  
            case .disconnected:
                print( "Disconnected" )

            case .connectionRefused:
                print( "Connection Refused" )
            case .connectionError:
                print( "Connection Error" )
            case .protocolError:
                print( "Protocol Error")
            default:
                print("unknown state: \(status.rawValue)")
            }

            NotificationCenter.default.post( name: Notification.Name(rawValue: "connectionStatusChanged"), object: self )
        }
    }

    if (connected == false)
    {
        let defaults = UserDefaults.standard
        var certificateId = defaults.string( forKey: "certificateId")

        if (certificateId == nil)
        {
            DispatchQueue.main.async {
                print("No identity available, searching bundle...")
            }

            // No certificate ID has been stored in the user defaults; check to see if any .p12 files
            // exist in the bundle.
            let myBundle = Bundle.main
            let myImages = myBundle.paths(forResourcesOfType: "p12" as String, inDirectory:nil)
            let uuid = UUID().uuidString;

            if (myImages.count > 0) {
                // At least one PKCS12 file exists in the bundle.  Attempt to load the first one
                // into the keychain (the others are ignored), and set the certificate ID in the
                // user defaults as the filename.  If the PKCS12 file requires a passphrase,
                // you'll need to provide that here; this code is written to expect that the
                // PKCS12 file will not have a passphrase.
                if let data = try? Data(contentsOf: URL(fileURLWithPath: myImages[0])) {
                    DispatchQueue.main.async {
                        print( "found identity \(myImages[0]), importing...")
                    }
                    if AWSIoTManager.importIdentity( fromPKCS12Data: data, passPhrase:"", certificateId:myImages[0]) {
                        // Set the certificate ID and ARN values to indicate that we have imported
                        // our identity from the PKCS12 file in the bundle.
                        defaults.set(myImages[0], forKey:"certificateId")
                        defaults.set("from-bundle", forKey:"certificateArn")
                        DispatchQueue.main.async {
                            print("Using certificate: \(myImages[0]))")
                            self.iotDataManager.connect( withClientId: uuid, cleanSession:true, certificateId:myImages[0], statusCallback: mqttEventCallback)
                        }
                    }
                }
            }

            certificateId = defaults.string( forKey: "certificateId")
            if (certificateId == nil) {
                DispatchQueue.main.async {
                    print( "No identity found in bundle, creating one...")
                }

                // Now create and store the certificate ID in NSUserDefaults
                let csrDictionary = [ "commonName":CertificateSigningRequestCommonName, "countryName":CertificateSigningRequestCountryName, "organizationName":CertificateSigningRequestOrganizationName, "organizationalUnitName":CertificateSigningRequestOrganizationalUnitName ]

                self.iotManager.createKeysAndCertificate(fromCsr: csrDictionary, callback: {  (response ) -> Void in
                    if (response != nil)
                    {
                        defaults.set(response?.certificateId, forKey:"certificateId")
                        defaults.set(response?.certificateArn, forKey:"certificateArn")
                        certificateId = response?.certificateId
                        print("response: [\(String(describing: response))]")

                        let attachPrincipalPolicyRequest = AWSIoTAttachPrincipalPolicyRequest()
                        attachPrincipalPolicyRequest?.policyName = PolicyName
                        attachPrincipalPolicyRequest?.principal = response?.certificateArn

                        // Attach the policy to the certificate
                        self.iot.attachPrincipalPolicy(attachPrincipalPolicyRequest!).continueWith (block: { (task) -> AnyObject? in
                            if let error = task.error {
                                print("failed: [\(error)]")
                            }
                            print("result: [\(String(describing: task.result))]")

                            // Connect to the AWS IoT platform
                            if (task.error == nil)
                            {
                                DispatchQueue.main.asyncAfter(deadline: .now()+2, execute: {
                                    print("Using certificate: \(certificateId!)")
                                    self.iotDataManager.connect( withClientId: uuid, cleanSession:true, certificateId:certificateId!, statusCallback: mqttEventCallback)

                                })
                            }
                            return nil
                        })
                    }
                    else
                    {
                        DispatchQueue.main.async {
                            print("Unable to create keys and/or certificate, check values in Constants.swift")
                        }
                    }
                } )
            }
        }
        else
        {
            let uuid = UUID().uuidString;

            // Connect to the AWS IoT service
            iotDataManager.connect( withClientId: uuid, cleanSession:true, certificateId:certificateId!, statusCallback: mqttEventCallback)
        }
    }
}

Discoonect from AWS

func disconnectToAWS(){
    print("Disconnecting...")

    DispatchQueue.global(qos: DispatchQoS.QoSClass.default).async {
        self.iotDataManager.disconnect();
        DispatchQueue.main.async {
            self.connected = false
            print( "Connect")

        }
    }
}

Subscribe topic

func subscribe(topic:String){
    let iotDataManager = AWSIoTDataManager(forKey: ASWIoTDataManager)

    iotDataManager.subscribe(toTopic: topic, qoS: .messageDeliveryAttemptedAtLeastOnce, messageCallback: {
        (payload) ->Void in
        let stringValue = NSString(data: payload, encoding: String.Encoding.utf8.rawValue)!
        print("received: \(stringValue)")
        if let jsonDict = try? JSONSerialization.jsonObject(with: payload, options: []) as? [String: Any]{
            DispatchQueue.main.async {
                if let type = jsonDict?["message_type"] as? String{
                    if type == "veh_live_info"{

                    }
                    else if type == "oil_change_info"{

                    }
                    else{

                    }
                }
            }
        }
    } )
    }

unsubscribe topic

func unsubscribe(topic:String){
    let iotDataManager = AWSIoTDataManager(forKey: ASWIoTDataManager)
    iotDataManager.unsubscribeTopic(topic)
}

refrence: https://github.com/awslabs/aws-sdk-ios-samples/tree/master/IoT-Sample/Swift/

Answer 3

There is a way to do it without requiring users to be authenticated with AWS Cognito, or generating X.509 certs for each client (like the above methods require - github example / amplify)

I wrote an article on how to do it simply using the AWS iOS SDK, no auth required. May be useful for your usecase:

1. On Medium (think it might be behind a paywall though)
2. IoT for all (Should be accessible - name would be ironic otherwise, haha)