Introduction

In this tutorials, we’re going to explore how we can setup Pusher Beams on an iOS client using an AWS Lambda function running Go to trigger the notifications.

Pusher Beams allows you to customize push notifications you send to your devices via a server. However it can be expensive to run a server 24 hours a day 7 days a week and we may only need to send notifications every so often. This is where AWS Lambda can help. Lambda functions are serverless and work on a pay as you go model (with a generous free tier). This means that you only pay for when you use the function.

Prerequisites

• A free AWS account. You can create one here.
• A free Pusher account. You can create one here.
• Go 1.x installed on your machine. Install instructions here.
• Xcode 10+
• MacOS
• An iOS device for testing notifications.
• An understanding of iOS development and Xcode environment.
• Cocoapods - Install instructions here.

Create your Lambda function

Creating a Pusher Beams instance

Login or create an account to access your dashboard here. Create a new beams instance using the dashboard.

Complete step one of the iOS setup guide, by providing your APNS key and team ID and clicking Continue. We will pick up the remainder later on in this tutorial. Press the X to exit the setup guide and you will be returned to your dashboard for that instance. Scroll to the bottom of the page and you will find your Beams instance ID and secret key, make note of these you will need them later.

Writing our function

We will need to install our packages and write our function on our local machine before we can upload it to a Lambda function. Create a new working directory on your local machine and within that create a file named index.go. Open your index.go file and add the following code:

    // index.go
    package main
    import (
            "fmt"
            "context"
            "github.com/pusher/push-notifications-go"
            "github.com/aws/aws-lambda-go/lambda"
    )
    
    type MyEvent struct {
            Title string `json:"title"`
            Message string `json:"message"`
    }
    
    const (
      instanceId = "YOUR_INSTANCE_ID"
      secretKey  = "YOUR_SECRET_KEY"
    )
    
    func HandleRequest(ctx context.Context, event MyEvent) (string, error) {
            beamsClient, _ := pushnotifications.New(instanceId, secretKey)
            publishRequest := map[string]interface{}{
                    "apns": map[string]interface{}{
                            "aps": map[string]interface{}{
                                    "alert": map[string]interface{}{
                                            "title": event.Title,
                                            "body":  event.Message,
                                    },
                            },
                    },
            }
    
            pubId, err := beamsClient.PublishToInterests([]string{"hello"}, publishRequest)
            if err != nil {
                    fmt.Println(err)
            } else {
                    fmt.Println("Publish Id:", pubId)
            }
            return fmt.Sprintf("Completed"), nil
    }
    
    func main() {
      lambda.Start(HandleRequest)
    }

This code will be used by our Lambda function later on to publish notifications to devices that our registered for the hello interest. Note how we import both the Pusher notifications Go package and the AWS Lambda package. We use the event.title and event.message to form part of the message. We’ll look at this in more detail when we come to test our integration. Remember to replace YOUR_INSTANCE_ID and YOUR_SECRET_KEY with the credentials from your Pusher Beams console.

Run the following commands to fetch packages and build your code:

    $ go get github.com/aws/aws-lambda-go/lambda
    $ go get github.com/pusher/push-notifications-go
    $ GOOS=linux go build index.go

Next we need to compress the directory we have been working in and make a .zip such that we can upload our code and dependencies to our function later on. Name your zip file GoLambda.zip.

Creating a Lambda function

Log in or create an account to access your AWS console here. Once you are logged in use the search bar to find Lambda and select it from the list.

Note: Set your AWS region to N. Virginia in the top right if it is not already.

You should be redirected to the Lambda service and see an option Create Function, select this. Choose the Author from Scratch option at the top of the next page. Complete the basic setup as shown in the image below.

• Function name - Name this whatever you want for example “Pusher-Beams-Go”.
• Runtime - We will be using Go 1.x so select this from the drop down list.
• Execution role - Select Create a new role from AWS policy templates. If you already have a role you would rather use you can select Use an existing role.
• Role name - You can name this anything you like for example “lambda_basic_execution”.
• Policy templates - You can leave this blank.

Once complete select the Create function button at the bottom of the page. You should be redirected to your Lambda function console once it has been created. We can ignore the Designer section of the console. This area allows us to tie together different AWS services, you may wish to use this with a production function such that it can be accessed from the wider internet. However, we will just be using the test service for the purpose of this tutorial.

Now we need to upload our code. In the Function code section select the Upload a .zip file from the Code entry type dropdown menu. Use the Upload button to search your local machine for the GoLambda.zip we created earlier. Finally change the Handler to be GoLambda/index, this will allow AWS Lambda to find our function within our folder. If everything looks like the below image click Save in the top right.

Create your iOS application

Now that we have created our Lambda function, we need to have a user that has actually registered for notifications and signed up for the hello interest so we can test out our implementation. We’re going to create a very basic app that doesn’t actually show anything to the user except for the notification on the lock screen.

Project setup

Create a new Single View App using Xcode and name it something like LambdaPush. Once the project is created we need to install the Beams SDK. Open the terminal and go to the working directory of the newly created project and run the following command.

    $ pod init

Open the newly created Podfile and add the following pod:

    pod 'PushNotifications'

In the terminal run:

    $ pod install

Make sure you close your Xcode project and reopen the newly created Xcode Workspace before continuing. Within your project capabilities make sure you have switched on the Push Notifications capability. Also turn on the Background Modes capability and tick the box for Remote Notifications.

Open your AppDelegate.swift file and replace its contents with the following. Remembering to replace the instance ID with your own.

    // AppDelegate.swift
    import UIKit
    import PushNotifications
    
    @UIApplicationMain
    class AppDelegate: UIResponder, UIApplicationDelegate {
        var window: UIWindow?
        let pushNotifications = PushNotifications.shared
    
        func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
            self.pushNotifications.start(instanceId: "YOUR_INSTANCE_ID")
            self.pushNotifications.registerForRemoteNotifications()
            try? self.pushNotifications.subscribe(interest: "hello")
    
            return true
        }
    
        func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
            self.pushNotifications.registerDeviceToken(deviceToken)
        }
    
        func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
            self.pushNotifications.handleNotification(userInfo: userInfo)
        }
    }

You can now run the application on your iOS device and accept to receive notifications. The SDK will then manage registering our interest in hello. Remember to replace YOUR_INSTANCE_ID with your instance ID credential from your Pusher Beams console.

Testing our implementation

Return to your Lambda function console. In the top right select the Test button. We need to configure a test option. Create a new test event like the below image. Notice how our keys in the JSON object are title and message. These are the event keys we were using in our code to provide the title and body for the push notification.

Once you are done press the Create button at the bottom. The dialog box will close and the test HelloTest should be selected in the dropdown menu by the Test button, Press Test. If everything has worked as expected you should receive a push to your device and a similar log output from your Lambda console.

Conclusion

We’ve learnt how to create an AWS Lambda function using Go that can publish a push notification using Pusher Beams to an iOS device. The source code for this tutorial can be found here.