Forem: Alba Rincón

Building a Telegram bot: share the words!

Alba Rincón — Mon, 08 Feb 2021 14:06:47 +0000

In the second post of this series, we added a package to make requests to the WordsAPI. In this last post, we'll use it to search words from the user input and share the results in any channel.

Configuring the bot 🤖

We want the bot to be accessible from any conversation in Telegram, to achieve that we need to make it an Inline bot.
This needs to be configured with @BotFather. We need to run the /mybots command, select the @share_the_word_bot from the list, go to the bots settings, and turn on Inline mode.

Once this setting is enabled, we can invoke the bot by typing @share_the_word_bot followed by the word we want to search for:

@share_the_word_bot cat

This will generate a query to our bot with the selected word as a string.

Reacting to the query ↩️

We'll need to change our bot handler to listen for any query (telebot.OnQuery) instead of listening for any text (telebot.OnText) and then capture the word from the query:

bot.Handle(telebot.OnQuery, func(q *telebot.Query) {
    word := q.Text
}

Using the API client

First, we'll need to initialize our pkg/words client to get the word definition:

api := words.New(
    "https://wordsapiv1.p.rapidapi.com/words",
    os.Getenv("WORDSAPI_TOKEN"),
    http.DefaultClient,
)

Next, in the query handler, we'll make the request:

bot.Handle(telebot.OnQuery, func(q *telebot.Query) {
    word := q.Text

    // get the word definitions
    definitions, err := api.Word(word)
    if err != nil {
        log.Printf("error searching for word: %s", err)
    }

    // format the results to send back to Telegram
    results := make(telebot.Results, len(definitions))
    for i, def := range definitions {
        results[i] = createResult(word, def, i)
    }

    // send the answer back
    err = bot.Answer(q, &telebot.QueryResponse{Results: results})
    if err != nil {
        log.Println(err)
    }
})

Each word definition is converted into a telebot.Result:

func createResult(word string, def words.Result, i int) *telebot.ArticleResult {
    result := &telebot.ArticleResult{
        Title:       word,
        Description: def.Definition,
    }

    result.SetContent(&telebot.InputTextMessageContent{
        Text:      def.Format(word),
        ParseMode: telebot.ModeMarkdownV2,
    })

    result.SetResultID(strconv.Itoa(i))

    return result
}

That's it! We can finally use our bot, just run

PORT=[port of our chice] \
WEBHOOK_URL=[public url] \
BOT_TOKEN=[bot token provided by @BotFather] \
    go run cmd/dictiobot/main.go

and try it!

Check the code: https://github.com/albarin/dictiobot/tree/03-share-the-words

Thank you! 😊👋

Building a Telegram bot: the words API

Alba Rincón — Mon, 08 Feb 2021 14:00:52 +0000

In the first post of this series we created our Telegram bot and managed to make it reply to any message with a fixed response.

Today we'll go a step forward and connect it to the API to start searching for words.

The words API 🎧

We'll be using the WordsAPI. The endpoint we'll need is

GET https://wordsapiv1.p.mashape.com/words/{word}

This will perform a search with the word we provide as a parameter on the URL and return the results with a lot of info about the word, in our case, we'll only use the definition, synonyms, antonyms, and examples of use.
You can check out this Postman collection to give it a try:

Creating the API client 🔄

We'll create a Go package that will help us make requests to the API. The package will live in the pkg/words folder.
To be initialized, it will need the baseURL, the token, and an http client:

type API struct {
    token   string
    baseURL string
    client  *http.Client
}

func New(baseURL, token string, client *http.Client) *API {
    return &API{
        token:   token,
        baseURL: baseURL,
        client:  client,
    }
}

Then we'll need a struct in which to store the JSON resulting from the request to the API. For our use case, we don't need all the properties that the request will return, we can specify on the Go struct the ones we need:

type responsePayload struct {
    Word    string   `json:"word"`
    Results []Result `json:"results"`
}

type Result struct {
    Definition string   `json:"definition"`
    Synonyms   []string `json:"synonyms,omitempty"`
    Antonyms   []string `json:"antonyms,omitempty"`
    Examples   []string `json:"examples"`
}

Last but not least, we need to create the function that will make the actual request. We will pass the word as a parameter and add the x-rapidapi-key with our token:

func (api *API) Word(word string) ([]Result, error) {
    url := fmt.Sprintf("%s/%s", api.baseURL, word)

    // create the request to the words endpoint
    req, err := http.NewRequest(http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }

    // add the token to the headers
    req.Header.Add("x-rapidapi-key", api.token)

    // make the request
    res, err := api.client.Do(req)
    if err != nil {
        return nil, err
    }

    // read the response
    body, err := ioutil.ReadAll(res.Body)
    defer res.Body.Close()
    if err != nil {
        return nil, err
    }

    // parse the json
    var payload responsePayload
    err = json.Unmarshal(body, &payload)
    if err != nil {
        return nil, err
    }

    return payload.Results, nil
}

With that, we have everything we need to interact with the WordsAPI, we can give it a try like this:

api := New("https://wordsapiv1.p.rapidapi.com/words", "{the_token}", http.DefaultClient)
result, _ := api.Word("big")

Check the code here: https://github.com/albarin/dictiobot/tree/02-the-words-api

In the next and last post of this series, we'll tie everything together and show the results of the word search in Telegram.

See you soon! 👋

Building a Telegram bot: the bot comes to life

Alba Rincón — Fri, 29 Jan 2021 19:44:00 +0000

I recently got curious about how to develop a Telegram bot. That's why I have decided to give it a try and document the process in this series of posts, so anyone can benefit from it as well.

What are we building?👷‍♀️

The idea is really simple: we are building a dictionary bot. It will allow us to search for a word and give us back info about it like meanings, synonyms, etc. We want it to work in any conversation or group we have, so we can share it with others.
We will develop it in Golang using the WordsAPI and deploying it to Heroku.

Creating the bot in Telegram 🤖

To create a bot in Telegram we need to use the @BotFather bot.
We need to use the /newbot command, give it a name and a username and we'll get a link and a token in return:

We can use the link to start a conversation with our bot and later we'll also need the token to connect to the bot from our code. We can always go back to the @BotFather and retrieve again the token or change some settings.

Make it talk 🗣

We are ready to start the implementation. We'll be using the Telebot Go library. Telebot is a framework that is going help us a lot interacting with the Telegram Bot API (setting up the bot, handling requests, sending messages, etc).

Our only goal now will be making our bot reply to any message we send to it.

First of all, we need to create our bot instance and configure it with an endpoint that Telegram will use to POST the messages the bot receives.
That endpoint will be something like

https://localhost:[PORT]/bot[BOT_TOKEN]

but it can't be in our local, we need to make it accessible to the internet so the bot can actually hit it.
For that purpose, we can use a tool called Ngrok and with a simple command it will expose the local port of our choice (4040 in this case) and give us back a URL.

ngrok http 4040
// returns a URL like https://89e834cae2b6.ngrok.io

We have everything ready, so we can now create our bot instance configured with the webhook endpoint in which it will receive all the updates from Telegram:

webhook := &telebot.Webhook{
    Listen: ":" + os.Getenv("PORT"),
    Endpoint: &telebot.WebhookEndpoint{
        PublicURL: os.Getenv("WEBHOOK_URL") + "/bot" + os.Getenv("BOT_TOKEN"),
    },
}

settings := telebot.Settings{
    Token:  os.Getenv("BOT_TOKEN"),
    Poller: webhook,
}

bot, err := telebot.NewBot(settings)
if err != nil {
    log.Fatalf("error initializing bot: %s", err)
    return
}

After that, we can add a handle to the bot that will trigger every time it receives any text message and replies to the user with I'm a 🤖!.

bot.Handle(telebot.OnText, func(msg *telebot.Message) {
    _, err := bot.Send(msg.Sender, "I'm a 🤖!")
    if err != nil {
        log.Printf("error sending message: %s", err)
        return
    }
})

bot.Start()

We are finally ready to test our bot! Let's run it with:

PORT=[port of our chice] \
WEBHOOK_URL=[public url] \
BOT_TOKEN=[bot token provided by @BotFather] \
    go run cmd/dictiobot/main.go

We can access the link that the @BotFather provided when we created the bot and send a message to it. Hopefully, we'll get our response back! 😅
And it works! 🙌 It's not too clever for now, but it will get better!

You can check the whole code here: https://github.com/albarin/dictiobot/tree/01-the-bot-comes-to-life

In the next chapter, we will build a service to make requests to the WordsAPI to be able to search for words.

See you! 👋

How to easily add co-authors to you commits

Alba Rincón — Mon, 20 Jul 2020 06:53:34 +0000

Git mob allows to add co-authors to git commits in an easy way. You can follow these steps to configure it for any repo you want.

1. Install the tool ⚙️

npm i -g git-mob

2. Create the co-authors file 📃

Create a file named .git-coauthors in your home directory with the following content:

{
  "coauthors": {
    "foo": {
      "name": "Foo"
      "email": "foo@company.com"
    },
    "bar": {
      "name": "Bar",
      "email": "bar@company.com"
    }
  }
}

The keys of each co-author object will be the ones you need to type when selecting your commit co-authors, so you can change them to whatever you prefer.

3. Create the git hook ⚓

git mob uses the git prepare-commit-msg hook to append the co-authors to the commit message. Choose one of the following options to configure it:

Option 1: Create the git prepare-commit-msg hook globally (for all repos)
Option 2: Create the git hook only for a specific repo
Option 3: Advanced case: make the git hook work alongside other prepare-commit-msg hooks

Option 1: Create the git prepare-commit-msg hook globally (for all repos)

Enable git templates:

git config --global init.templatedir '~/.git-templates'

This tells git to copy everything in ~/.git-templates to your repo .git/ directory when you run git init.

Create the file .git-templates/hooks/prepare-commit-msg in your home folder

mkdir -p .git-templates/hooks && touch .git-templates/hooks/prepare-commit-msg

with the following content:

#!/usr/bin/env node
let exec = require('child_process').exec,
    fs = require('fs');

const commitMessage = process.argv[2];
// expect .git/COMMIT_EDITMSG
if(/COMMIT_EDITMSG/g.test(commitMessage)){
    let contents = "";
    exec("git mob-print",
        function (err, stdout) {
        if(err) {
            process.exit(0);
        }

        // opens .git/COMMIT_EDITMSG
        contents = fs.readFileSync(commitMessage);

        if(contents.indexOf(stdout.trim()) !== -1) {
            process.exit(0);
        }

        const commentPos = contents.indexOf('# ');
        const gitMessage = contents.slice(0, commentPos);
        const gitComments = contents.slice(commentPos)

        fs.writeFileSync(commitMessage, gitMessage + stdout + gitComments);
        process.exit(0);
    });
}

make it executable running:

chmod +x .git-templates/hooks/prepare-commit-msg

and make it available in the repo you want by entering the repo folder and running:

git init

Option 2: Create the git hook only for a specific repo

Create the file .git/hooks/prepare-commit-msg in your repo folder with the following content:

#!/usr/bin/env node
let exec = require('child_process').exec,
    fs = require('fs');

const commitMessage = process.argv[2];
// expect .git/COMMIT_EDITMSG
if(/COMMIT_EDITMSG/g.test(commitMessage)){
    let contents = "";
    exec("git mob-print",
        function (err, stdout) {
        if(err) {
            process.exit(0);
        }

        // opens .git/COMMIT_EDITMSG
        contents = fs.readFileSync(commitMessage);

        if(contents.indexOf(stdout.trim()) !== -1) {
            process.exit(0);
        }

        const commentPos = contents.indexOf('# ');
        const gitMessage = contents.slice(0, commentPos);
        const gitComments = contents.slice(commentPos)

        fs.writeFileSync(commitMessage, gitMessage + stdout + gitComments);
        process.exit(0);
    });
}

and make it executable with:

chmod +x .git-templates/hooks/prepare-commit-msg

Option 3: Advanced case: make the git hook work alongside other prepare-commit-msg hooks

Only one script can be executed in each specific git hook, so in order to run multiple scripts for one hook, we'll need to create a parent script that will invoke all others.

Change the content of you prepare-commit-msg for this:

Create a folder named prepare-commit-msg.d in the same folder and move all your other prepare-commit-msg hook scripts into it. Your hooks folder structure should look similar to:

.git-templates/hooks
├── prepare-commit-msg
└── prepare-commit-msg.d
    ├── add-co-authors
    ├── some-script
    ├── ...
    └── some-other-script

Don't forget to make every script executable with:

chmod +x {path-to-my-script}

If you this globally remember to make it available in the repo you want by entering the repo folder and running:

git init

4. Create the template ✍️

In your repo folder run:

git mob --installTemplate && touch .git/.gitmessage

This will create the file .git/.git-mob-template where it will write the selected co-authors into.

5. Start a mob/pairing session 👯‍♀️

When you start working with your teammates type:

git mob foo bar

The names you use here are the same you used on the .git-coauthors file before.

When you do git commit you'll see this already in the message:

Co-authored-by: Foo <foo@company.com>
Co-authored-by: Bar <bar@company.com>
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# On branch master

6. Work alone 🤷

To start working by yourself just type:

git solo

Other useful commands

Show current co-authors:

git mob --print

Show all available co-authors and their aliases:

git mob --list

Check https://github.com/findmypast-oss/git-mob for more info.

How I used Go to generate images for my dad’s meetups

Alba Rincón — Wed, 15 Jul 2020 06:20:11 +0000

I recently read a great article by Mat Ryer about programmatically generating images in Go and got inspired by it to solve a repetitive task I usually do every month.

My dad is the head of an organization called Projecte LOC that promotes reading to kids and adults in Cornellà de Llobregat, Spain. Once a month they organize a meet-up: either a literary dinner with a book author to talk about a book or a storytelling session. He usually asks me to create an image to illustrate the event and sends the details via email to all the members of the organization. The illustration looks like this:

It's quite annoying to do it every single month by hand, importing the image, aligning text, adjusting everything... I usually make mistakes copying the day, the time and the title from the email he sends to me. I end up re-doing it entirely after he finds typos/mistakes.

So when I saw Mat's article I immediately thought that I could do something to improve this tedious process both for myself and my dad. Wouldn't it be great to have something where he would enter a few variable data about the meet-up (title, guest, image and date) and I would programmatically generate the whole image?

I needed something really simple and user friendly for him to enter the info. That was an easy decision: Typeform. He's used to typeforms and I know the API really well, after all, I helped build it. Then, I would take advantage of Typeform webhooks to get the response details from the form submission, process the info about the meet-up, generate the corresponding image and provide a link for him to download it. 💪

1. Creating the Typeform 🛠

First, I created the typeform with all the fields that would change for each meet-up. Each field has a unique identifier called reference, which is useful to identify the fields on the response payload that we'll receive on the webhook. By default, this reference is a long alphanumeric string, but I modified it on the Create Panel to look a bit more human-readable so I could identify each answer quickly in the code.

Next, I created the webhook on the Connect Panel pointing it to an endpoint that will handle each typeform submission.

2. Handling the webhook ⚓️

2.1. Signature verification ✍️

When creating a webhook we are exposing the endpoint URL to the internet, which is not secure. Potentially anyone with bad intentions could request to it with any data. I wanted to be sure that I was only processing webhooks coming from Typeform, so I added a secret on my webhook configuration. Then, Typeform would use it to sign the webhook payload and add it as a header on the request.

To accept an incoming webhook request, the first thing the handler has to do is verify that Typeform sent it.

This is done with the verifySignature function that takes multiple parameters: the request body, the shared secret with Typeform, and the value of the Typeform-Signature header.

Then, it computes the signature for the received payload with the secret and compares the result with the receivedSignature.

func verifySignature(payload []byte, secret, receivedSignature string) (bool, error) {
    signature, err := computeSignature(payload, secret)
    if err != nil {
        return false, err
    }

    return signature == receivedSignature, nil
}

func computeSignature(payload []byte, secret string) (string, error) {
    h := hmac.New(sha256.New, []byte(secret))

    _, err := h.Write(payload)
    if err != nil {
        return "", err
    }

    return "sha256=" + base64.StdEncoding.EncodeToString(h.Sum(nil)), nil
}

If the comparison succeeds we are sure the request is coming from Typeform so the execution can proceed, otherwise, the handler stops and returns an error.

func generateHandler(w http.ResponseWriter, r *http.Request) {
    // 1. Read the request body
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    defer r.Body.Close()

    // 2. Verify the signature
    ok, err := verifySignature(body, os.Getenv(secretToken), r.Header.Get("Typeform-Signature"))
    if err != nil || !ok {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    // 3. The verification succeeded so we can process the webhook 🙌
    ...
}

2.2. Creating a Poster from the submission 🖼

At this point, we are sure the request is perfectly safe. The next step is actually reading and parsing the JSON body of the request and storing it somewhere. To do that, we create a variable of type Webhook and unmarshal the request body into it.

Next, we want to convert the Webhook into a Poster variable holding only the answers to each of the typeform questions. This will simplify the rendering task, we won't have to work anymore with a complicated Webhook struct with full of non relevant data.

func generateHandler(w http.ResponseWriter, r *http.Request) {
        // 1. Read the request body
      ...
        // 2. Verify the signature
      ...

        // 3. Parse the webhook from the request body
        var wh poster.Webhook
        err = json.Unmarshal(body, &wh)
        if err != nil {
            log.WithFields(log.Fields{"error": err}).Error("could not unmarshal webhook")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        // 4. Convert the webhook data to a Poster
        p := wh.ToPoster()

        // 5. Generate the image
        ...

The ToPoster() function loops over the answers of the webhook using the reference attribute (that we previously set when creating the form) to identify to which poster field it corresponds.

type Poster struct {
    Title  string
    Guest  string
    Date   time.Time
    Time   string
    PicURL string
    Type   string
}

func (w Webhook) ToPoster() Poster {
    poster := Poster{}

    for _, answer := range w.FormResponse.Answers {
        switch answer.Field.Ref {
        case "title":
            poster.Title = answer.Text
        case "guest":
            poster.Guest = answer.Text
        case "date":
            date, _ := time.Parse("2006-01-02", answer.Date)
            poster.Date = date
        case "time":
            poster.Time = answer.Text
        case "type":
            poster.Type = answer.Choice.Label
        case "pic":
            poster.PicURL = answer.PicURL
        }
    }

    return poster
}

3. Generating the image 👩‍🎨

Finally we have our Poster ready to be rendered! 👏

func generateHandler(w http.ResponseWriter, r *http.Request) {
        // 1. Read the request body
      ...
        // 2. Verify the signature
      ...
        // 3. Parse the webhook from the request body
        ...
        // 4. Convert the webhook data to a Poster
        ...

        // 5. Generate the image
        err = p.Render()
        if err != nil {
            log.WithFields(log.Fields{"error": err}).Error("could not generate poster")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }
}

Let's dive into the Render method. We will use the Go Graphics https://github.com/fogleman/gg rendering library to generate the final image.

func (p Poster) Render() error {
    ctx := gg.NewContext(width, height)

    err := drawBackground(ctx, "assets/images/background.png")
    if err != nil {
        return err
    }

    err = drawBackground(ctx, "assets/images/logos.png")
    if err != nil {
        return err
    }

    err = drawPicture(ctx, p)
    if err != nil {
        return err
    }

    err = drawText(ctx, p)
    if err != nil {
        return err
    }

    err = ctx.SavePNG("poster.png")
    if err != nil {
        return err
    }

    return nil
}

The poster always has a similar format with the same background and sponsors logos at the bottom, so that's the first part we will render with the drawBackground and drawLogos methods.

Drawing the picture poster is a bit more interesting since it's uploaded through the typeform and we don't really know the size it will have. In the Poster variable, we have the url of the picture. First we will download it to a temporary file with the [poster.Picture()](https://github.com/albarin/nit-del-llop/blob/master/pkg/poster/poster.go#L71) method, resize it to fit into the poster and position it in the right image coordinates.

func drawPicture(ctx *gg.Context, poster Poster) error {
  // Download the picture to a local file
    filepath, err := poster.Picture()
    if err != nil {
        return err
    }

  // Load it
    pic, err := gg.LoadImage(filepath)
    if err != nil {
        return err
    }

  // Resize it
    resizedPic := resize.Thumbnail(
        uint(pic.Bounds().Dx()),
        250,
        pic,
        resize.Lanczos3,
    )

  // Position and draw it
    contentWidth := ctx.Width()/2 - margin
    ctx.DrawImageAnchored(resizedPic, margin+contentWidth/2, 185, 0.5, 0)

  // Delete the temporary file
    err = os.Remove(filepath)
    if err != nil {
        return err
    }

    return nil
}

The only part left now is drawing all the info about the meet-up (title, guest, image and date) with the drawText method. The challenge here is making sure all the text lines fit in our image, since it comes from a user input we have no idea how long those lines could be. We need to change the font size depending on the length of the line.

To simplify the task we create an array of Line structs holding all the info of the poster. Each Line has the text to render, the margin to position it, the font name, and the default font size. If the font size is too big causing the text to overflow the image, it will be decreased until it fits.

func drawText(ctx *gg.Context, poster Poster) error {
    ctx.SetColor(color.White)

  // Lines with all the info to render
    lines := []Line{
        ...
        {
            text:      fmt.Sprintf(`"%s"`, poster.Title),
            marginTop: 290,
            fontSize:  45,
            fontPath:  RobotoBold,
        },
        {
            text:      "amb",
            marginTop: 25,
            fontSize:  25,
            fontPath:  RobotoLight,
        },
        {
            text:      fmt.Sprintf("%s", poster.Guest),
            marginTop: 20,
            fontSize:  45,
            fontPath:  RobotoBold,
        },
        {
            text:      poster.When(),
            marginTop: 35,
            fontSize:  45,
            fontPath:  RobotoLight,
        },
        {
            text:      poster.Where(),
            marginTop: 20,
            fontSize:  45,
            fontPath:  RobotoLight,
        },
        ...
    }

    contentWidth := float64(ctx.Width()/2 - margin)
    positionX := margin + contentWidth/2
    positionY := margin

    // Loop through each line adjusting the font and drawing it
    for _, line := range lines {
        err := ctx.LoadFontFace(line.fontPath, line.fontSize)
        if err != nil {
            return err
        }

        err = adjustFontSize(ctx, line, contentWidth)
        if err != nil {
            return err
        }

        positionY = calculatePositionY(ctx, line, positionY)
        ctx.DrawStringAnchored(line.text, positionX, positionY, 0.5, 0)
    }

    return nil
}

And we have our poster! We just need to save it as a PNG file.

func (p Poster) Render() error {
  // Draw everything
    ...

    // Store the poster in a file
    err = ctx.SavePNG("poster.png")
    if err != nil {
        return err
    }

    return nil
}

4. Downloading the poster ⬇️

Lastly, the most important part. You must be thinking how my dad is going to access this beautiful poster file and download it. 🤔Let me explain:

As you saw in the last step, we always save the image with the same name, so we know for sure that after the typeform submission, we'll have the poster available in the same path. We'll take advantage of that fact and create another handler on the /download endpoint that shows the poster on the browser.

func download(w http.ResponseWriter, r *http.Request) {
    image, err := os.Open("poster.png")
    if err != nil {
        log.WithFields(log.Fields{"error": err}).Error("could not open image")
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    defer image.Close()

    w.Header().Set("Content-Type", "image/png")
    _, err = io.Copy(w, image)
    if err != nil {
        log.WithFields(log.Fields{"error": err}).Error("could not write image")
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
}

Now, we go back to our typeform Create Panel and add that link into the Thank You Screen button. With this setup, after the form is submitted, the Thank You Screen will be shown and we'll be able to download the poster by clicking on the button.

5. Deploying it 🚀

I wanted to practice my Docker skills a bit so I decided to use Docker and Heroku to deploy the application.

5.1. Dockerize it 📦

The first thing to do was to dockerize the app. I did it with a multi-stage build. In the first part, we are using golang:1.14-alpine image to build the app into a binary called poster. Then, in the second step we use the alpine:latest image to copy the binary from the previous stage and run it.

FROM golang:1.14-alpine AS builder
ADD . /poster
WORKDIR /poster
RUN go mod download
RUN CGO_ENABLED=0 go build -ldflags "-s -w" -o poster cmd/poster/*.go

FROM alpine:latest
RUN apk --no-cache add ca-certificates
COPY --from=builder /poster ./
RUN chmod +x poster
CMD ./poster

5.2. Deploy to Heroku

I choose to go with Heroku for the deployment, because they support Docker image deploy with their CLI app.

I created a free account and installed the CLI app. After that, creating the application was just logging in and running a simple command:

heroku create

As a result of that command a new app is created in our account and it displays a generated URL to access it.

Once your app is created, you need to tell Heroku which Docker file to use to run your app. We create a heroku.yml at the root of our application.

build:
  docker:
    web: Dockerfile

Finally, our app is ready to be deployed using git:

git push heroku master

Now that the app has been deployed. We can access the handler at https://{something}.herokuapp.com/download

The last step is to update our webhook and Thank You screen buttons to point to the new URLs. Now it works! 💥

I took the opportunity to change the design a bit, this is what it looks like now! 😁

Here you can find the full code: https://github.com/albarin/nit-del-llop

Thanks for reading, any comments or questions are welcomed 😊