Deploying a Serverless Youtube-To-Gif Telegram bot with OpenFaaS
Today we’ll create a Telegram bot which will accept a YouTube URL and send you a gif. To accomplish this, we will deploy this bot with the OpenFaaS Framework. The architecture is as follows:
When you’re done, you’ll have this functionality:
Let’s get started.
1. Create the Telegram Bot
Open a chat with the BotFather and send him the /newbot
message to initiate the bot creation process. After you have created the bot, you will get a token that looks like 110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw
.
2. Deploy OpenFaaS on EC2
It is very simple to deploy the full OpenFaaS platform to an EC2 instance. We will walk through the process step by step.
First, go to the AWS EC2 console and click ‘Launch Instance’. On the next page, choose the Ubuntu AMI.
The default instance type is t2.micro
, which will work. On the ‘Configure Instance’ page, open the ‘Advanced Details’ dropdown. We’ll paste the following block of text into the ‘User data’ text area:
#cloud-config
repo_update: true
repo_upgrade: all
runcmd:
- curl -sSL https://get.docker.com/ | sudo sh
- sudo usermod -a -G docker ubuntu
- docker swarm init
- cd /tmp
- git clone -b higherTimeout https://github.com/ericstoekl/faas/
- cd ./faas
- ./deploy_stack.sh
- cd /tmp
- curl -sSL https://cli.openfaas.com | sudo sh
Once that’s done, it should look like this:
Click the ‘Next’ button until you get the the security groups page. Create a security group that has TCP port 8080 open. Open port 22 as well, because SSH is needed.
Launch the instance and make sure you have the private key that is needed to log in.
Now ssh into the machine with the following command:
$ ssh -i <your-key-pair.pem> ubuntu@<your-ec2-public-dns>
The cloud-config file will run each of the commands listed one by one, which may take a few minutes. When it’s all done, you should be able to run faas-cli version
and see the following output:
At this point, your OpenFaaS deployment should be up and running. Make sure of it by running faas-cli list
, and you should get the following type of output:
You can also check that your deployment of OpenFaaS is good-to-go by going to http://<your-AWS-machine-public-DNS>:8080/
in the web browser from your local machine. You should get a nice UI:
3. Deploy the core functions of the Youtube-To-Gif Telegram bot on OpenFaaS
The core functions are:
youtube-dl
— This is a function that will take a URL of a youtube video as STDIN, and put the raw data of that youtube video (MP4 format) to STDOUT.gif-maker
— This function will take a raw MP4 file in STDIN and send raw data of a GIF file to STDOUTtelegram-gif-bot
— This function will receive bot commands from the API Gateway (to be set up next) and pass the commands to theyoutube-dl
andgif-maker
functions. Essentially a dispatcher, this function uses the Function Director pattern. You will need to edit the code of this function to add your Telegram bot API key.
Let’s deploy these functions. We’ll start by cloning my github repo, which contains a YAML file that faas-cli
will use to build and deploy the 3 aforementioned functions:
~ $ git clone https://github.com/ericstoekl/tg-youtubegif
~ $ cd tg-youtubegif
Before we deploy these functions, we will need to edit the telegram-gif-bot
function. Open up the tg-youtubegif.yml
file in the project root, and add your API Key that you got from the BotFather in step 1 along with the bolded line:
functions:
telegram-gif-bot:
lang: node
handler: ./telegram-gif-bot
image: ems5311/telegram-gif-bot:0.2
environment:
BOT_TOKEN: <YOUR TOKEN HERE>
write_timeout: 65
read_timeout: 65
write_debug: true
Save the file. You’re ready to build and deploy these functions, with the following command:
~/tg-youtubegif $ faas-cli build -f tg-youtubegif.yml
~/tg-youtubegif $ faas-cli deploy -f tg-youtubegif.yml
Next, wait for the functions to become active. If you run docker service ls
, you should see the youtube-dl
, gif-maker
, and telegram-gif-bot
become active when their replica count goes from 0/1
to 1/1
.
Once the functions are finished deploying, test the functionality out by opening a new terminal on your local machine and running the following command:
curl <your-AWS-public-DNS>:8080/function/youtube-dl -d "https://www.youtube.com/watch?v=NtgtMQwr3Ko" | curl -X POST <your-AWS-public-DNS>:8080/function/gif-maker --data-binary @- > yt.gif
Now check that the GIF was downloaded successfully:
4. Create the API Gateway
Next, we’ll create an API Gateway on AWS to act as a reverse-proxy to our OpenFaaS platform.
First hit the “Create API” button in API Gateway:
Name your bot something like OpenFaas-TgBot
. You don’t need to provide a description. After you submit, you will end up with a screen that looks like this:
Now we add a POST
method to the API Gateway. Click the ‘Actions’ drop-down menu and select ‘Post’:
Then hit the checkmark next to the drop-down, and you will get to the Setup screen. For the ‘Endpoint URL’ we’ll enter in http://<public-DNS-to-instance>:8080/function/telegram-gif-bot
.
Leave the ‘Content Handling’ box as ‘Passthrough’. Hit ‘Save’. Next, click the drop-down menu again (titled ‘Actions’) and select ‘Deploy API’. We’ll create a new stage:
Click ‘Deploy’, then click on your ‘prod’ stage. You will be given a URL (note that it is HTTPS, which Telegram requires) which you can use to accept Telegram bot messages.
Finally, on your local machine, set your Telegram bot to post messages to this API Gateway endpoint:
$ curl -XPOST https://api.telegram.org/bot<YOUR_BOT_API_KEY>/setWebhook\?url\=<YOUR_API_GATEWAY_ENDPOINT>
If all goes well, you will get the following response:
{"ok":true,"result":true,"description":"Webhook was set"}
Now, you are ready to test your telegram bot. Open a new chat in Telegram with the bot you created in Step 1, and send it the following URL: https://www.youtube.com/watch?v=ojvTSRA-O-Y
Conclusion
Today we deployed a Telegram bot with the OpenFaaS platform running on a simple AWS deployment. Keep in mind that this is just a simple proof-of-concept, and a real deployment would not use just a single EC2 instance, but rather have auto-scaling functionality so that more instances would automatically be launched with increased load on the service. Something like faas-rancher could be used for this purpose, and there is a blog post with detailed instructions on how to deploy it here.
In any case, if you liked this tutorial, please leave a comment with any and all feedback. Thanks!