In this guide we will be looking at combing a simple Go server with Redis, and deploying it all for free with pebl.
Setup
- Make sure that you have docker and Go installed.
- Install the pebl cli by following the steps here: https://docs.pebl.io/setup
- Head over to pebl.io and create a free account
After creating your account, make sure to claim your free *.pebl.rocks
subdomain (https://www.pebl.io/signup/claim), as we'll be using this for the rest of the series!
We will be using hey.pebl.rocks
to make things concrete, so make sure to replace any instances of that with your own subdomain.
Project Creation
Now it's time to create our project!
-
Create a scratch folder to act as the root of the project. For this tutorial we'll be creating
pebl-tutorial
:
$ mkdir ~/work/pebl-tutorial
-
Then initialize the project by creating a Go module:
$ cd ~/work/pebl-tutorial $ go mod init pebl-tutorial
-
Download the pebl Go SDK by running
go get
inside the project folder:
$ cd ~/work/pebl-tutorial $ go get github.com/peblcloud/go
Adding Redis
Let's first install the redis client that we will use:
$ go get github.com/redis/go-redis/v9
Then create a main.go
at the root of the project, and paste the following:
package main
import (
"net/http"
"github.com/peblcloud/go"
"github.com/redis/go-redis/v9"
)
func main() {
redisConn, _ := pebl.Redis("redis-1")
rdb := redis.NewClient(&redis.Options{
Addr: redisConn.Addr,
})
svc := http.NewServeMux()
svc.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
count, _ := rdb.Get(context.Background(), "count").Result()
res := fmt.Sprintf("current count: %s", count)
w.Write([]byte(res))
})
svc.HandleFunc("/incr", func(w http.ResponseWriter, _ *http.Request) {
rdb.Incr(context.Background(), "count")
})
pebl.Service(svc, "hey.pebl.rocks")
}
Pebl is a unique cloud platform, one where everything is driven with code. There are no configurations required! Here we are utilizing pebl.Service
to create a service out of the standard net/http
Go server, which will serve at hey.pebl.rocks
. (Make sure to change this to your own subdomain that you claimed).
In a similar fashion, we get access to redis by using pebl.Redis
. This method returns a struct that contains the connection information for the redis instance. This gets passed into the redis client.
And finally we have two endpoints configured on the server: /incr
which increments the key count
, and the root endpoint /
that returns the current count.
Running Locally
Let's try running this locally!
Local Cluster
First we need to initialize the local cluster:
$ pebl up
:: initializing new pebl cluster...
:: done!
:: run `pebl info` to see logs, endpoints, and other info about the running cluster!
$
Then execute pebl info
to attach to the running cluster. This let's you see information about the running cluster, including any running workloads, logs, etc. The info screen should look something like this:
pebl cluster version: 0.0.9
ctrl-C or q to exit the info pane
(exiting will not stop the cluster)
══ logs ═══════════════════════════════
And you can exit the info pane by pressing q
or Ctrl-C
.
Running the Project
Now make sure you are at the root of the project, and execute pebl run
:
$ cd ~/work/pebl-tutorial
$ pebl run
:: building golang project...
:: staging build at: /tmp/dir
:: containerizing the build...
:: starting container...
$
And now if you check your info pane, you should see two workloads, the endpoint and the redis instance.
pebl cluster version: 0.0.9
ctrl-C or q to exit the info pane
(exiting will not stop the cluster)
redis: redis-1 → localhost:55000
endpoint: hey.pebl.rocks → localhost:55001
══ logs ════════════════════════════════
Sending Requests
The info pane shows the locally bound port for the service. In our example it is bound to :55001
, but your own case will differ. Send a test curl to the bound port:
$ curl localhost:55001/incr
$ curl localhost:55001/
current count: 1
$ curl localhost:55001/incr
$ curl localhost:55001/incr
$ curl localhost:55001/
current count: 3
$
Making Changes
Now to make it a bit more interesting! Let's add an endpoint to /reset
, which will set the count
key back to zero.
package main
import (
"net/http"
"github.com/peblcloud/go"
"github.com/redis/go-redis/v9"
)
func main() {
redisConn, _ := pebl.Redis("redis-1")
rdb := redis.NewClient(&redis.Options{
Addr: redisConn.Addr,
})
svc := http.NewServeMux()
svc.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
count, _ := rdb.Get(context.Background(), "count").Result()
res := fmt.Sprintf("current count: %s", count)
w.Write([]byte(res))
})
svc.HandleFunc("/incr", func(w http.ResponseWriter, _ *http.Request) {
rdb.Incr(context.Background(), "count")
})
svc.HandleFunc("/reset", func(w http.ResponseWriter, _ *http.Request) {
rdb.Set(context.Background(), "count", "0", 0)
})
pebl.Service(svc, "hey.pebl.rocks")
}
Notice the new /reset
handler that's been attached to svc
.
In other platforms making changes can be an involved process. But with pebl we just need to re-run the project! Pebl understands what it means to update an endpoint and will automatically handle switching the underlying server to the latest version without any interruption.
Run the project again with pebl run
and then send requests to the /reset
endpoint:
$ curl localhost:55001/
current count: 3
$ curl localhost:55001/reset
$ curl localhost:55001/
current count: 0
$
Cloud Runtime
To really give you a sense of why the pebl approach is so powerful, we are going to deploy this project to the cloud. And we are going to do this without any changes, no extra configuration required!
Just use pebl deploy
at the root of the project:
$ cd ~/work/pebl-tutorial
$ pebl deploy
Once deployed, you can visit the pebl console to see the running redis instance. You can also create a local tunnel to the remote redis instance in order to inspect or debug:
$ pebl tunnel redis
:: tunnel established at: 127.0.0.1:50000
:: use redis-cli to connect:
:: redis-cli -p 50000
And as the output suggests, we can use redis-cli
to the locally bound port to tunnel to your remote redis instance:
$ redis-cli -p 50000
127.0.0.1:50000> get counter
"1"
note that there's no need to create a "tunnel" to your local cluster. the info pane already shows the locally bound port which you can use to inspect the local redis!
Next
You can continue to make changes to the Go server, perhaps adding authentication or caching.
For more tutorials, check out our many guides. Pebl is currently also available in Python and Node.
For a reference to the Go SDK, check out https://pkg.go.dev/github.com/peblcloud/go
For an overview of all cloud functionality available with pebl, check out the reference.
Top comments (0)