DEV Community: pebl

Hosting static websites with versioning for free

Jin Lee — Wed, 23 Aug 2023 03:58:35 +0000

Pebl is a cloud computer.

It is the first cloud platform that meets developers where they are the most comfortable — code. No more configs. Just embed the cloud right into your application with pebl's cloud SDK.

We just released pebl v0.1.2 which includes support for versioned folders. This makes it super easy to host static websites with versioning, meaning that you can quickly rollback to previous versions of your website!

This should only take you about five minutes. If you run into any issues, hop on our discord to ask for help.

Setup

We will be continuing from our first guide where we configured static web hosting with pebl. Follow the tutorial before continuing.

Versioning

The new release of pebl will automatically version your folders.

$ pebl folder upload build static
 :: uploading folder as name static
 :: success! the new uploaded version is: coawer
$

And we can reference these versions directly in mount:

await pebl.mount("static:coawer", "/static");

Note that you can leave the version out of the name like we had done previously. In this case the latest version of the folder will be chosen.

Making a Change

Go ahead and make a modification to your website. In our example, we are using the react starter. The react start page displays the react logo that rotates clockwise. We'll make a small change so that it goes the other way.

$ cd project-folder/my-app
$ cat src/App.css
...
@keyframes App-logo-spin {
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(-360deg); // <-- this line has changed
  }
}
$

Now let's build and upload, just like before.

$ cd project-folder/my-app
$ npm run build
$ pebl folder upload build static

Then re-deploy our existing node server:

$ cd project-folder/server
$ pebl deploy

Now when you visit your website, you should see the change reflected.

Rolling Back

But sometimes we need to rollback our changes! Maybe it turns out the react logo was meant to turn clockwise after all.

Here we can use the pebl cli to list the available versions:

$ pebl folder list static
NAME
static:coawer
static:dtzmoj

These are sorted by time, which means we can reference static:dtzmoj in order to rollback our website.

Update your index.js like so:

import express from "express";
import * as pebl from "pebl";

// reference static:dtzmoj to rollback!
await pebl.mount("static:dtzmoj", "/static");

const app = express();

app.use(express.static("/static"));
app.get('/*', function (req, res) {
  res.sendFile("/static/index.html");
});

pebl.service(app, "your-subdomain.pebl.rocks");

And once you deploy this with pebl deploy, you will see the old version!

We have a ton of guides for how to use pebl. And make sure to join our discord!

Host your React, Angular, Svelte, or any other framework for free with pebl!

Jin Lee — Sat, 19 Aug 2023 06:17:57 +0000

Pebl is a cloud computer. It gives you programmatic bindings to control the cloud right from your application. No more configs, or stringing together disparate tools in adhoc ways. Just code to define your cloud!

We just released pebl v0.1.1, which includes support for mount. This makes it super easy to host any static website with pebl.

So let's get into it, and make sure to join our discord!

Setup

We first need to configure our development environment. We've made this super fast, so it should only take you 5 minutes.

Head over to pebl.io to create your free account. It's very important that you claim your free pebl.rocks subdomain! We will be using this to host your react app.
Install the pebl CLI
```
 $ curl https://www.pebl.io/install | sh
```
If you want to go through the steps manually, you can follow the steps here.
Authenticate the pebl CLI by running pebl auth
Finally, create a project folder
```
 $ mkdir project-folder
```

The Static Bundle

Let's generate an example website. If you already have a project that you want to use, you can skip this section.

We will be using create-react-app which makes it super fast to get started:

$ cd project-folder
$ npx create-react-app my-app
$ cd my-app
$ npm run build

At this point you will have a folder ~/project-folder/my-app/build which contains the base react app.

Uploading the Bundle

Now that you have a static bundle, we can upload it into pebl's cluster. You can use pebl's CLI to do this:

$ cd project-folder/my-app
$ pebl folder upload build static

If you have an existing project that you are using, make sure to navigate to that project and run pebl folder upload build static.

Serving with Express

We'll utilize Express + Node to serve this react bundle, though pebl supports Python and Go which can also be used.

Let's create a folder server to house the server, and initialize a node project:

$ cd project-folder
$ mkdir server
$ cd server
$ npm init -y
$ npm pkg set type="module"
$ npm pkg set scripts.start="node index.js"
$ npm i express pebl@v0.1.1

Now create an index.js which will contain our express server:

import express from "express";
import * as pebl from "pebl";

await pebl.mount("static", "/static");

const app = express();

app.use(express.static("/static"));
app.get('/*', function (req, res) {
  res.sendFile("/static/index.html");
});

pebl.service(app, "your-subdomain.pebl.rocks");

Note the last line! Replace your-subdomain.pebl.rocks with the subdomain that you claimed while you signed up!

Deploy

Now we will deploy using pebl's CLI. Run pebl deploy within the server folder:

$ cd project-folder/server
$ pebl deploy

This will be available immediately! Navigate to your url using your browser and you should see this react app. Make sure to use https, as all pebl deployments get TLS certificates for free.

Explore

Now that we've got things working, let's unpack a few key things.

SDK

The power of pebl comes from its SDK, which provide programmatic bindings that unlock cloud capabilities.

In this example we utilized pebl.mount and pebl.service. You can check out the pebl reference to find out more information about how they work.

Adding APIs

The key benefit of pebl is that you can now easily extend your server to provide API's that your frontend can rely on. It's as simple as extending the express app to have routes:

app.get('/some/endpoint', function (req, res) {
  // your custom API logic here
});

Updates

If you want to update your website, it's super easy! Just go through the process of uploading your new bundle with pebl folder upload, then re-run pebl deploy within the server/ folder.

So something like:

$ cd project-folder/my-app
$ npm run build
$ pebl folder upload build static
$ cd ../server
$ pebl deploy

We have a ton of guides for how to use pebl. And make sure to join our discord!

Deploying Go & Redis For Free With Pebl!

Jin Lee — Sat, 22 Jul 2023 03:44:55 +0000

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!

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.

Getting started with Node and pebl — a free cloud platform!

Jin Lee — Thu, 22 Jun 2023 22:01:50 +0000

Pebl recently released support for Node in release 0.0.7!

As part of that we are starting a dedicated series on using Node and pebl which will go into detail about how to utilize all the different cloud capabilities that pebl offers.

But we thought it'd be fun to start off the series with a quick guide that is actually quick, and should take 5 minutes!

When you are done you will have a Node project configured with a standard http.Server deployed to the cloud and serving live traffic!

Setup

First create a free account at pebl.io. Make sure to claim your free *.pebl.rocks subdomain! We will be using this to deploy with in this tutorial.

Then download the pebl CLI, the steps are outlined in the docs.

You also need to have Node and Docker installed on your system.

Project

Now we're ready to initialize the node project! Create a folder to be the root of our project:

$ mkdir quickstart

Then place this package.json inside the folder (Note that you could also use npm init to do this):

{
  "name": "node",
  "version": "1.0.0",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "pebl": "0.0.8"
  }
}

Then install the pebl@0.0.8 dependency by running npm install

$ cd quickstart
$ npm install

added 1 package, and audited 2 packages in 739ms

found 0 vulnerabilities
$

A simple server

Let's create an index.js with a simple server that utilizes pebl's service functionality:

import * as pebl from 'pebl';
import * as http from 'http';

const requestListener = function (req, res) {
  res.writeHead(200);
  res.end("hello, world!\n");
};
const server = http.createServer(requestListener);

pebl.service(server, "your-domain-here.pebl.rocks")

Here make sure to place your own pebl.rocks subdomain!

Deploying

Now we are ready to deploy the project.

First run pebl auth to authenticate the pebl CLI with your pebl account.

Then run pebl deploy at the root of the project!

$ pebl deploy
 :: building node project...
 :: containerizing the build...
 :: build success!
 :: uploading...
 :: success!
$

Now you can send requests to your deployment with curl:

$ curl https://your-domain-here.pebl.rocks

Make sure to use https, as all pebl deployments get free SSL certificates!

FAQ

Can I run this locally?

Yes! One power of pebl is that you can run the same code locally and in the cloud, without any modification. We will go into more details about how to do this, but the short version is: first create a local cluster with pebl up, then you can run local workloads with pebl run in the project folder.

Can I use Express?

Yes! In fact you use any server that conforms to net.Server.listen.

Can I use my own custom domain with pebl?

We are currently beta testing this feature! If you are interested, fill out this typeform link and we will be in touch: https://ie0rdzi5b9h.typeform.com/to/V0PJ90un.

mysql support! — pebl supports mysql with release 0.0.6

Jin Lee — Tue, 13 Jun 2023 06:06:28 +0000

Quick Summary

With release 0.0.6, pebl now supports creating mysql instances in both Python and Go.

Longform

Both Python and Go will now have a new method that will initialize a mysql instance on your behalf. The usage is quite similar to the way redis is handled.

Python

In python the method is pebl.mysql that takes a single string argument to represents the mysql handle. The return value is a dictionary containing four keys, host, port, user, and password.

These are the exact keys that are needed for pymysql.connect, and so you can pass the dictionary as keywords args.

import pebl
import pymysql

conn = pebl.mysql("mysql")
db = pymysql.connect(**conn)

with db.cursor() as cursor:
    cursor.execute("show databases")
    print(cursor.fetchall())

Go

In Go the method is pebl.Mysql that takes a single string argument to represent the mysql handle. The return value is of type MysqlConn, which has the necessary fields required to connect to the mysql instance.

package main

import (
    "database/sql"

    "github.com/peblcloud/go"
    "github.com/go-sql-driver/mysql"
)

func main() {
    conn, _ := pebl.Mysql("mysql-1")

    cfg := mysql.Config{
        User:   conn.User,
        Passwd: conn.Password,
        Net:    "tcp",
        Addr:   conn.Addr,
    }

    db, _ := sql.Open("mysql", cfg.FormatDSN())

    if err := db.Ping(); err == nil {
        println("Connected!")
    }
}

pebl info

When using pebl info to display information about the local cluster, you will now see entries for any mysql instances that you utilize.

The information will include the local port that you can utilize to connect, which you can pass into mysql:

$ mysql --host 127.0.0.1 --port 32799 -uroot

Upgrading

Make sure to download the latest pebl CLI, which will be needed in order to utilize the new release on your local cluster. Follow the section about installing the CLI in the setup guide.

Go

The Go SDK is available with the 0.0.6 tag. You can update your existing Go projects by running go get -u github.com/peblcloud/go@v0.0.6.

Python

The Python SDK is available as pre-built docker images. Update your Python projects by changing the Dockerfile to utilize one of the 0.0.6 images.

pebl CLI update — initialize base pebl projects

Jin Lee — Sat, 10 Jun 2023 00:33:29 +0000

Quick Summary

The latest pebl CLI release can create base pebl projects for either Python or Go, helping you get started quickly.

Longform

One feedback we've heard is that it can be a bit cumbersome to set up a new project for pebl, especially when the setup doesn't work on the first try.

In order to make this process more efficient and get you started right away, the latest pebl CLI has a built-in command to create correct pebl projects that can serve as a starting point.

Go

For Go based projects, run:

$ pebl init go my-project
 :: initializing project with endpoint: hey.pebl.rocks
 :: initializing go project...
 :: creating main.go ...
$

Note that initializing a Go projects relies on the system installed Go binary, so make sure that is installed before invoking pebl init.

Python

For Python based projects, run:

$ pebl init python my-project
 :: initializing project with endpoint: hey.pebl.rocks
 :: creating Dockerfile ...
 :: creating main.py ...
$

Running

Once initialized, the project is immediately ready! You can execute pebl run inside the initialized project to get started.

Pebl Release 0.0.5

Jin Lee — Thu, 01 Jun 2023 19:56:32 +0000

Quick Summary

Release 0.0.5 has support for streaming production logs using the CLI and updates to the Go package.

Longform

pebl CLI

Previously the only way to look at logs from the cloud runtime was to go to our console. The latest pebl CLI now supports the command pebl logs, which will stream those logs so that you can see them on your terminal.

$ ./pebl logs
[06/01 12:43:49] foo
[06/01 12:44:34] bar
[06/01 12:44:35] hello, world!

To upgrade you can follow the setup steps.

Go SDK

Previously our Go package was structured such that the pebl bindings were under the sdk package, meaning that you had to import the package using github.com/peblcloud/go/sdk.

Based on user feedback we have decided to move all the bindings to the root level, and to change the package name to pebl. In short you can now do this:

package main

import (
    "net/http"
    "github.com/peblcloud/go"
)

func main() {
    service := http.NewServeMux()

    service.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello, world!\n"))
    })

    pebl.Service(service, "svc.internal")
}

To upgrade you can run go get github.com/peblcloud/go@v0.0.5 in your Go projects.

Microservices with pebl — a complete and free cloud platform

Jin Lee — Wed, 31 May 2023 19:24:34 +0000

Overview

In this guide I want to introduce pebl, a complete and free cloud platform.

Unlike the normal approach to Infrastructure as Code, pebl doesn't rely on declaring a set of yaml files to control your cloud. Instead pebl embeds cloud capabilities within your application through language specific SDKs.

Getting Started

Signing Up

So first we need to sign up for a free account at pebl.io.

Choose your desired identity provider and follow the steps. And make sure to go through claiming your free *.pebl.rocks subdomain! We'll be using this for the rest of the tutorial.

Docker & pebl CLI

There are only two system requirements for pebl, which is Docker and the pebl CLI. If you don't have Docker installed, head over to the docker website and follow their directions.

For pebl CLI, choose to correct link on the pebl's setup docs. Make sure you select the correct download link for your own system! If you are using a Mac you can check if your system is an Intel or M1 by going through the Apple Menu then About This Mac.

Verify that the CLI was installed correctly by running pebl without any args:

$ pebl
usage:

    pebl {command}

available commands:

       up  start the local pebl cluster.
     down  stop the local pebl cluster.
     info  attach and show info about the local pebl cluster.
      run  execute a pebl program locally.
   deploy  execute a pebl program in the cloud.
   tunnel  creates a tunnel to a redis instance.
     auth  manages the credentials needed for certain commands.
  version  print the version of the cli.

$

Simple Service

The core building block that pebl provides is a service. On other platforms it might be referred to as a serverless application. In essence pebl's service is a server that can respond to requests.

Now let's dive into pebl by creating a very simple service using Python.

Hello World!

Create a scratch project folder somewhere on your system. In our examples we will be using ~/work/scratch:

$ mkdir -p ~/work/scratch

But feel free to choose another scheme that makes sense for your own setup. This folder will act as the root of our project.

Now let's create a subfolder that will contain our simple hello world service.

mkdir ~/work/scratch/hello

Create a main.py (~/work/scratch/hello/main.py) that will hold the main method and paste in the following:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def root():
    return "hello, world!\n"

import pebl
pebl.service(app, "hey.pebl.rocks")  # put your own domain here

The first section of main.py should look very familiar if you've used Flask before. It's a very simple Flask definition, with a single handler on the root path. The last two lines are where we declare that this Flask application should be a service, hosted at your *.pebl.rocks endpoint.

At this point you might expect that we have to create some separate pebl specific yaml. But really this single method call is all it takes to define a service with pebl! So to recap:

Cloud capabilities (pebl.service) are incorporated into the application as regular code
You can rely on any other Python library without additional configuration, like Flask

Now to run this, we will be relying on pebl's base Docker image to create a re-usable container. Go ahead and create a Dockerfile (~/work/scratch/hello/Dockerfile) with the following content:

FROM peblcloud/python
COPY . .
RUN pip install flask
ENTRYPOINT python -u main.py

Local Runtime

Pebl let's you execute your code locally to ensure correctness and to provide a super fast iteration cycle. First start a local cluster that will contain all our local workloads with pebl up:

$ pebl up
 :: initializing new pebl cluster...
 :: done!
 :: run `pebl info` to see logs, endpoints, and other info about the running cluster!
$

Once the cluster is configured, navigate to the hello subfolder and execute pebl run:

$ cd ~/work/scratch/hello
$ pebl run
 :: building docker project...
 :: starting container...
$

Then run pebl info to see the state of the running cluster.

You should see something like this, but with your own *.pebl.rocks subdomain instead of hey.pebl.rocks. Go ahead and try sending a request to your server.

$ curl localhost:32807
hello, world!
$

Make sure you put in the correct port as shown on your info pane!

Cloud Runtime

By embedding your cloud infrastructure usage into your application, pebl unlocks a key benefit: The ability to deploy the exact same application to different runtimes, without any modifications.

In other words, there's no longer a need to do any environment specific checks or define multiple config files for local vs. production deploys.

So pebl makes it super easy to migrate your applications to the cloud once you are done testing them locally. Just run pebl deploy in a similar fashion to pebl run:

$ cd ~/work/scratch/hello
$ pebl deploy

If you get authentication errors, make sure to run pebl auth and follow the steps!

Once the deploy is successful, try sending a request with curl. Make sure to use https as all services in the cloud get TLS by default, and pebl disallows non-TLS traffic.

$ curl https://hey.pebl.rocks
hello, world!
$

You can also head over to the pebl console to get a report of all incoming traffic to your endpoints.

Microservices

A common way to structure cloud workloads is to break them into small services, each serving a disparate part of the larger system. With pebl we can achieve that by utilizing the internal services capability.

Internal services are similar to pebl.service that we used previously, with one key difference. They are only exposed to your other workloads, and are not configured for external traffic.

So in this section we will explore adding an internal service, and utilizing Go instead of Python to highlight the language agnostic feature of pebl.

Go Setup

Let's create a subfolder within our scratch folder to hold our Go setup.

$ mkdir ~/work/scratch/go

Then initialize a Go project using go mod init:

$ cd ~/work/scratch/go
$ go mod init scratch

And unlike Python, since Go is compiled we actually don't need a Dockerfile. Instead we need to download the pebl package for Go:

$ cd ~/work/scratch/go
$ go get github.com/peblcloud/go

User Service

And to motivate a real usage, we will be creating an internal Go service that acts as a user service, one that handles managing user data. Create a main.go (~/work/scratch/go/main.go):

package main

import (
    "github.com/peblcloud/go"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("this is an internal service!\n"))
    })

    pebl.InternalService(mux, "go.internal")
}

So just as we had done previously with Python, we are creating a server object based on the net/http. Then passing configured server object into pebl's SDK with the pebl.InternalService call.

Note that unlike the serivce we defined previously, we are providing a seemingly invalid domain of go.internal. For internal services the endpoint can be anything, though we recommend you use an easy-to-remember scheme, such as a .local or .internal TLD.

Let's try running this! Same as before execute pebl run to run it locally:

$ cd ~/work/scratch/go
$ pebl run
 :: building golang project...
 :: staging build at: /var/folders/92/_vg8jtqx7kncxb_9jlpw8rmm0000gn/T/3019178735
 :: containerizing the build...
 :: starting container...
$

Now when you inspect the info pane, you should see another entry tagged as internal:

You can send requests to this new internal endpoint with curl:

$ curl localhost:32808
this is an internal service!
$

Note that the ability to send requests like this to internal service is provided out of convenience while running locally. When deployed to the cloud runtime, you won't be able to access the internal services from outside the cluster.

Redis

Now our internal Go service isn't very interesting because it doesn't really do anything based on our request. In order to support a much wider set of applications, pebl provides persistence through Redis. And just as we have done so far, we unlock this capability through the SDK.

So let's update the Go service (~/work/scratch/go/main.go) by incorporating Redis.

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"

    "github.com/peblcloud/go"
    "github.com/redis/go-redis/v9"
)

func main() {
    connInfo, _ := pebl.Redis("users")
    client := redis.NewClient(&redis.Options{
        Addr: fmt.Sprintf("%s:%d", connInfo.Host, connInfo.Port),
    })

    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        query, _ := url.ParseQuery(r.URL.RawQuery)
        name := query.Get("name")
        userInfo, _ := client.HGetAll(context.Background(), name).Result()
        payload, _ := json.Marshal(userInfo)
        w.Write(payload)
    })

    pebl.InternalService(mux, "go.internal")
}

Then update our module dependencies by running go mod tidy, which should automatically pull down github.com/redis/go-redis/v9. If for some reason this isn't working, you can manually run go get github.com/redis/go-redis/v9.

Now run this Go service by executing pebl run inside ~/work/scratch/go/. Your info pane should now list the redis instance we are using named users.

If you try and send requests to your internal Go service at this point, you'll always get an empty result because our redis instance has no user data yet.

$ curl 'localhost:32808?name=alice'
{}
$ curl 'localhost:32808?name=bob'
{}

But you can quickly manage the data in your local redis by using the exposed port shown on the info pane.

$ redis-cli -p 32809
127.0.0.1:32809> hset alice name alice email alice@example.org
(integer) 2
127.0.0.1:32809> hset bob name bob email bob@example.org
(integer) 2

Now when you send requests with either alice or bob as the query, you'll get their user info json in the response:

$ curl 'localhost:32808?name=alice'
{"email":"alice@example.org","name":"alice"}
$

Proxying

Now to utilize this internal service, we will be proxying a subset of requests from our external Python service to our intenal Go service. Let's update our main.py in the ~/work/scratch/hello/ folder:

from flask import Flask
import requests

app = Flask(__name__)

@app.route("/")
def root():
    return "hello, world!\n"

@app.route("/user/<name>")
def user_service(name):
    r = requests.get(f"http://go.internal?name={name}")
    return r.text, r.status_code

import pebl
pebl.service(app, "hey.pebl.rocks")  # put your own domain here

So here we are relying on the popular requests library in order to send /user requests to the internal Go service at go.internal:80. Once again the power of pebl is this ability to incorporate other Python libraries at ease without any external configuration. But before we can run this locally, we need to ensure that the requests library is available for use within the container. So update the Dockerfile:

FROM peblcloud/python
COPY . .
RUN pip install flask requests
ENTRYPOINT python -u main.py

Go ahead and try running this! You'll be able to query the external endpoint at the /user path to get access to the internal service:

$ curl localhost:32807/user/alice
{"email":"alice@example.org","name":"alice"}
$ curl localhost:32807/user/bob
{"email":"bob@example.org","name":"bob"}
$

Deploying

Go ahead and deploy these changes! First deploy the internal Go service:

$ cd ~/work/scratch/go
$ pebl deploy

Then invoke pebl deploy once again in the python subproject:

$ cd ~/work/scratch/hello
$ pebl deploy

Pebl automatically implements zero downtime updates to services. This means that there won't be any dropped requests during this transition. Once the deploy is complete you can try sending the same requests to the cloud runtime:

$ curl https://hey.pebl.rocks/user/alice
{}
$ curl https://hey.pebl.rocks/user/bob
{}

And as expected you should be seeing empty results as our cloud runtime doesn't have the data we filled for our local runtime.

Redis Management

In order to access redis that's in the cloud runtime, we can utilize pebl CLI's pebl tunnel command:

$ pebl tunnel
 :: tunnel established at: 127.0.0.1:59039
 :: use redis-cli to connect:
 :: redis-cli -p 59039

This tunnel proxies local traffic to your redis instances in the cloud. You can use the redis-cli with the -p argument to connect to the proxied port and set the same data we used locally:

$ redis-cli -p 59039
127.0.0.1:59039> hset alice name alice email alice@example.org
(integer) 2
127.0.0.1:59039> hset bob name bob email bob@example.org
(integer) 2

Now your requests to the cloud will return the same results as before:

$ curl https://hey.pebl.rocks/user/alice
{"email":"alice@example.org","name":"alice"}
$ curl https://hey.pebl.rocks/user/bob
{"email":"bob@example.org","name":"bob"}

Next Steps

So we've explored three capabilities of pebl — services, internal services, and redis. You can explore the rest of pebl's offerings by digging into the SDK reference.

You can also follow our many guides on how to accomplish common cloud tasks.

Pebl Release 0.0.4

Jin Lee — Fri, 26 May 2023 00:16:17 +0000

Quick Summary

Previously all pebl services were external facing. But a very common way of
organizing distributed systems is by creating internal (micro)services that
handle a localized part of the whole system.

With release 0.0.4, we introduce a new SDK binding that supports internal
only services.

Longform

The previous service binding remains unchanged. Using it will create
a service that is exposed to external traffic.

Release 0.0.4 introduces the new internal_service binding. Unlike the
external counterpart, this method will create a service that's only
reachable from other running workloads.

package main

import (
    "net/http"
    "github.com/peblcloud/go/sdk"
)

func main() {
    service := http.NewServeMux()

    service.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("some internal service!\n"))
    })

    sdk.InternalService(service, "svc.internal")
}

Note that the endpoint parameter here can be anything as long as it is
in a valid domain format. We recommend creating an internally consistent
scheme by adopting a TLD for all internal services, such as .internal
or .local.

Upgrading

Make sure to download the latest pebl CLI, which will be needed in order
to utilize the new release on your local cluster. Follow the section
about installing the CLI in the setup guide.

Go

The Go SDK is available with the 0.0.4 tag.
You can update your Go projects by running go get github.com/peblcloud/go@v0.0.4.

Python

The Python SDK is available as pre-built docker images.
Update your Python projects by changing the Dockerfile to utilize
one of the 0.0.4 images.

Go SDK!

Jin Lee — Thu, 18 May 2023 07:19:48 +0000

Release 0.0.3 now includes support for Go!

Quick Summary

Pebl now supports projects in Go! Update to the latest CLI and follow this guide to get started.

Longform

At pebl we often talk about creating a full abstraction layer for the cloud. And at the core of this idea is that we can provide the full set of cloud capabilities through a programmatic binding, allowing developers to encode their infrastructure as code. An important mark of whether this is feasible is by expanding the set of languages that we support.

So we are very excited to release pebl's Go SDK, meaning that you can now incorporate pebl's cloud capabilities into your Go projects!

Short Example

The Go SDK is available as a public package.

Simply run go get github.com/peblcloud/go and incorporate in your app:

package main

import (
    "net/http"
    "github.com/peblcloud/go/sdk"
)

func main() {
    service := http.NewServeMux()

    service.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello, world!\n"))
    })

    sdk.Service(service, "hey.pebl.rocks")
}

To run, use the familiar pebl run cli command at the root of the project. Note that unlike Python projects, Go projects do not require a Dockerfile!

For a more detailed tutorial of using pebl's Go SDK, check out our guided example.

Python

A short note on the Python SDK, we have expanded the set of base images available for your use! Now you can combine the desired pebl SDK version (latest is 0.0.3) with the desired Python version (3.10, 3.11, 3.12). You can find more information on our peblcloud dockerhub.

Modern Cloud Workflow with Pebl - Part 4

Jin Lee — Mon, 08 May 2023 22:49:35 +0000

In part 3 we explored adding object store capabilities with an intuitive file system interface.

In part 4 we are going to look at adding scheduled tasks to our application.

Decorating Scheduled Tasks

With pebl scheduled tasks are created with a python decorator placed on the function that you want to run at a regular interval:

import pebl

@pebl.cron("task", "@hourly")
def task():
  import time
  print(" -- task running at:", time.time())

The first argument to the decorator is a unique identifier provided by you. Pebl ensures that there's only one scheduled task ever registered for each identifier, meaning that updates & redeploys behave as expected.

The second argument is the interval, and currently only two values are supported, @hourly and @daily.

Simple Example

Let's incorporate a scheduled task into our Flask application! And while doing so let's also utilize the object store. We will create a simple daily task that snapshots the current count.

import pebl
import redis
from flask import Flask

conn = redis.Redis(**pebl.redis("redis-1"))

app = Flask(__name__)

@app.route("/")
def root():
  return "Hello!"

@app.route("/counter", methods=["POST"])
def increment():
  conn.incr("counter")
  return "success!"

@app.route("/counter", methods=["GET"])
def get_count():
  curr = conn.get("counter")
  return {
    "counter": int(curr) if curr else 0
  }

@pebl.cron("snapshot", "@hourly")
def counter_snapshot():
  path = f"/snapshots/{int(time.time())}"
  curr = conn.get("counter")
  with open(path, "w") as f:
    f.write(curr.encode())

pebl.service(app, "your-subdomain.pebl.rocks")

Give this a try by running it with pebl run!

Conclusion

And with that we have covered four key capabilities provided by the pebl SDK, and also how to run and deploy pebl workloads.

pebl cli release - redis tunnel support!

Jin Lee — Fri, 05 May 2023 18:29:45 +0000

Quick Summary

The latest pebl cli now supports creating tunnels to your redis instances!
Make sure to download the latest cli in order to easily gain access to
your remote redis instances.

Longform

If you don't have redis running on pebl's cloud runtime yet, head
over to the intro to redis guide
to create one!

setup

Follow the setup guide to install
the latest pebl cli. Make sure that the cli is properly installed
by checking the output of pebl version:

$ pebl version
0.0.2

pebl tunnel

To create the tunnel, simply run the pebl tunnel command and supply
the name of the redis instance you want to connect to:

$ pebl tunnel my-redis-1

However, if you have just one redis in our cloud runtime, you can omit
the name argument:

$ pebl tunnel

This will automatically create a tunnel to your one redis instance.

redis-cli

The command allocates a local port that will proxy traffic between
your local machine to the cloud redis instance. The command will
output the local port and an example redis-cli command that you
can invoke:

$ pebl tunnel
tunnel established at: 127.0.0.1:12345
use redis-cli to connect:
redis-cli -p 12345

Then simply invoke the redis-cli with the -p option to connect.

$ redis-cli -p 12345
127.0.0.1:12345> ping
PONG

And that's it! That should give a fast way to inspecting your
redis instances. For more information on how to utilize redis
on the pebl runtime, head over to the
intro to redis guide.