PubNub Go SDK v7.2.1
This page outlines the steps to follow to create a simple Hello World application with PubNub. This covers the basics of integrating PubNub in your application: setting up a connection to PubNub, and sending and receiving messages.
PubNub account
Sign in or create an account to create an app on the Admin Portal and get the keys to use in your application.
When you create a new app, the first set of keys is generated automatically, but a single app can have as many keysets as you like. We recommend that you create separate keysets for production and test environments.
Download the SDK
Download the SDK from any of the following sources:
Use go
To integrate PubNub into your project using the go command:
go get github.com/pubnub/go/v7
If you encounter dependency issues, use the dep ensure command to resolve them.
Get the source code
View the supported platforms here.
Configure PubNub
In the IDE of your choice, create a new file and add the following code. Make sure to replace myPublishKey and mySubscribeKey with your app's publish and subscribe keys from the Admin Portal.
func main() {
config := pubnub.NewConfigWithUserId("myUniqueUserId")
config.SubscribeKey = "mySubscribeKey"
config.PublishKey = "myPublishKey"
pn := pubnub.NewPubNub(config)
}
For more information, refer to the Configuration section of the SDK documentation.
Add event listeners
Listeners help your program react to events and messages. You can implement custom logic to respond to each type of message or event.
Copy the code below to configure your program such that when it receives a message, the content of the message is printed.
listener := pubnub.NewListener()
doneConnect := make(chan bool)
donePublish := make(chan bool)
msg := map[string]interface{}{
"msg": "Hello world",
}
go func() {
for {
select {
case status := <-listener.Status:
switch status.Category {
case pubnub.PNDisconnectedCategory:
// This event happens when radio / connectivity is lost
case pubnub.PNConnectedCategory:
For more information, refer to the Listeners section of the SDK documentation.
Publish and subscribe
To receive messages sent to a particular channel, you subscribe to it. When you publish a message to a channel, PubNub delivers that message to everyone subscribed to that channel.
In this code, publishing a message is triggered when the subscribe call is finished successfully. The Publish() method uses the msg variable that you can see in the code below.
To subscribe, you send a subscribe call.
msg := map[string]interface{}{
"msg": "Hello world!"
}
pn.Subscribe().
Channels([]string{"hello_world"}).
Execute()
<-doneConnect
response, status, err := pn.Publish().
Channel("hello_world").Message(msg).Execute()
if err != nil {
// Request processing failed.
// Handle message publish error
For more information, refer to the Publish and Subscribe section of the SDK documentation, and to Publishing a Message.
Putting it all together
Your file should now look similar to the following:
import (
"fmt"
pubnub "github.com/pubnub/go"
)
func main() {
config := pubnub.NewConfigWithUserId("myUniqueUserId")
config.SubscribeKey = "demo"
config.PublishKey = "demo"
pn := pubnub.NewPubNub(config)
listener := pubnub.NewListener()
doneConnect := make(chan bool)
donePublish := make(chan bool)
Now, run your program to see if you did everything correctly. You should see "Hello world" printed in the console.
Congratulations! You've just subscribed to a channel and sent your first message.
Walkthrough
Instead of focusing on the order in which you wrote the code, let's focus on the order in which it runs. The program you just created does a few things:
- configures a PubNub connection
- adds the
status,message, andpresenceevent listeners - subscribes to a channel
- publishes a message
Configuring PubNub
The following code is the minimum configuration information you need to supply to send and receive messages with PubNub. For more information, refer to the Configuration section of the SDK documentation.
func main() {
config := pubnub.NewConfigWithUserId("myUniqueUserId")
config.SubscribeKey = "mySubscribeKey"
config.PublishKey = "myPublishKey"
pn := pubnub.NewPubNub(config)
}
Add event listeners
Listeners help your program react to events and messages. You can implement custom logic to respond to each type of message or event.
You added three listeners to the code: status, message, and presence. Status listens for status events and presence listens for presence events, but in this case, both listeners are a no operation implementations. The remaining listener, message, listens for incoming messages on a particular channel. When it receives a message, the code simply prints the received message. This is why you see "Hello world" displayed in the console.
listener := pubnub.NewListener()
doneConnect := make(chan bool)
donePublish := make(chan bool)
msg := map[string]interface{}{
"msg": "Hello world",
}
go func() {
for {
select {
case status := <-listener.Status:
switch status.Category {
case pubnub.PNDisconnectedCategory:
// This event happens when radio / connectivity is lost
case pubnub.PNConnectedCategory:
For more information, refer to the Listeners section of the SDK documentation.
Publishing and subscribing
PubNub uses the Publish/Subscribe model for real-time communication. This model involves two essential parts:
- Channels are transient paths over which your data is transmitted
- Messages contain the data you want to transmit to one or more recipients
When you want to receive messages sent to a particular channel, you subscribe to it. When you publish a message to a channel, PubNub delivers that message to everyone who is subscribed to that channel. In this example, you subscribe to a channel named hello_world.
A message can be any type of JSON-serializable data (such as objects, arrays, integers, strings) that is smaller than 32 KiB. PubNub will, in most cases, deliver your message to its intended recipients in fewer than 100 ms regardless of their location. You can also share files up to 5MB.
When your program successfully connects to a channel, it calls the Publish() method, which sends the "Hello world" message.
msg := map[string]interface{}{
"msg": "Hello world!"
}
response, status, err := pn.Publish().
Channel("hello_world").Message(msg).Execute()
if err != nil {
// Request processing failed.
// Handle message publish error
}
You can subscribe to more than one channel with a single subscribe call but in this example, you subscribe to a single channel:
pn.Subscribe().
Channels([]string{"hello_world"}).
Execute()
For more information, refer to the Publish and Subscribe section of the SDK documentation, and to Publishing a Message.
Next steps
You have just learned how to use the Go SDK to send and receive messages using PubNub. Next, take a look at the SDK's reference documentation which covers PubNub API in more detail.