Forem: Sirclesam

Send SMS with Chrome extension and AWS Lambda: Walkthrough

Sirclesam — Tue, 24 Sep 2019 20:26:02 +0000

I will browse through imgur when I have some time to kill, and often that means seeing pictures of things I know my ladyface will like, it's usually puppies.

For a while I'd just right-click copy the URL, then open android SMS web app messages.google.com, find the lady, paste and DONE. However, after a particularly cute day I found my self doing this several times in a row and it's not very efficient, so one lazy morning I got ambitious and got something cobbled together that worked...but wasn't ideal.

My first version worked by sending the URL to my node server that's running one of my personal projects with some special query strings and using that to fire off an SMS using the Twilio module. While this worked, it is less than ideal since it meant I have this code on my server that has nothing to do with its main purpose, but for something I cooked up in a few hours one morning, it will do.

I finally got around to getting this to work the way I wanted, and that seems much more suited to the task, which is using AWS Lambda functions, and that's what I'm going to walk through here.

I'll touch on the outline, then we'll step through the individual steps for getting it up and running.

We'll be using a chrome extension to hit an AWS API Gateway, that's tied to a Lambda function that uses AWS SNS to send an SMS. Let's get started working backwards.

Note: You'll need an AWS account with a credit card tied to it, everything I use is very cheap (0.00645 per SMS) but amazon still needs to be able to charge you.

SNS

1) Go to the SNS home page

2) create a new topic, named anything you like.

3) Give your topic a display name. Note the first 10 characters of this will show up on every SMS you send. So for mine being PupperSMS texts look like this:

PupperSMS>http://i.imgur.com/cRF0KoB.jpg

4) Create an SMS subscription for this topic.

Click create subscription, select the ARN for the topic you just created.
Put the phone number you intend to send things to in the endpoint, I use the full +11234567890 style
I advise using your number at first so your intended audience doesn't have to get your test messages.
You can include multiple subscriptions here if you want to send to multiple numbers.

5) Test it.

You can test that it works by clicking 'Publish Message' enter something in the body and click 'Publish Message' at the bottom. You should get an SMS from a 5 digit number at the number you put in with your display name at the beginning.

6) Keep track of the ARN, we'll need that for later.

Lambda

Now for the fun stuff.

1) Go to the AWS lambda homepage

2) Click 'create a function', choose 'author from scratch' and runtime as 'python 2.7'

it will take a bit, AWS also creates an IAM role for your lambda func
Note: I had errors with the default role creation, so I used one I created in IAM. You can create one here choose lambda for services and AdministratorAccess for permissions. It's probably overkill for what we're doing but will work for now.

3) Add in the lambda python code:

from __future__ import print_function

import json
import urllib
import boto3
import os

print('Loading message function...')

def lambda_handler(event, context):
    if event["queryStringParameters"]["key"] == os.environ["KEY"]:
        send_to_sns(event["queryStringParameters"]["url"], context)
        message = "Message Sent!"
    else:
        message = "Invalid Key - try again"
    return {
        "statusCode": 200,
        "body": json.dumps(message)
    }

def send_to_sns(smsMessage,context):
    sns = boto3.client('sns')
    sns.publish(
        TopicArn={YOUR SNS ARN HERE},
        Message=smsMessage
    )

    return ('Sent a message to an Amazon SNS topic.')

Before this will work you need to grab the ARN from your SNS and set it to the TopicArn above. Like this:
TopicArn="arn:aws:sns:us-west-2:1234567890:mySMS",

You can test this by changing the lambda handler to lambda_function.send_to_sns and a test event to just a string. Once you hit test, it should send an SMS with that string to your phone.

Change the handler back to lambda_function.lambda_handler and I'll briefly go over what's going on in the other function.

We're going to use AWS API gateway to activate this function, which will give us a URL we can hit, and using something called Lambda Proxy which will allow us to take query strings from a URL and pass them to the lambda function in the event object.

These are stored in the 'queryStringParameters' object. The 'url' is the data we're interested in, but you'll notice there's also a 'key' parameter. This is to add a bit of security to our api so that not anyone in the world can trigger this, but only when the api is hit with the correct key value.

This can probably be done with AWS security features, but I haven't gotten that far yet - if you have a better method please let me know!

Pick something that you'll use as your security key. I use a UUID string, you can generate one here: https://www.uuidgenerator.net/

Right under the code on your lambda function, there's a section for environment variables - place your KEY / UUID here. It doesn't need to be long, but it should be long enough that brute force is out of the question. You could even correct horse battery staple it: https://www.xkcd.com/936/.

API Gateway

Time to expose our lambda to the world!

1) Go to API Gateway portal

2) Click 'get started' to create a new API

3)Select New API, give it a name and description, leave endpoint as regional, click 'create API'

4) Click 'actions' --> 'create method', select GET from the dropdown and click the checkmark.

5) Select integration type: Lambda Function

6) Check 'use lambda proxy integration'

7) select your lambda function by name in the lambda function field.

Select ok to allow the API access.

8) We'll need to enable query strings so we can pass data to our api and our lambda function. Click method request

8) Test your API by clicking the Test with the lightning icon.

Enter url=canYouHearMeNow&key=YOURKEY in the query string field and hit test
You should see 'message sent' and get a sms on your phone!
Almost there, home stretch!

9)Deploy your API. Click 'actions' and select deploy API

Create a new stage name
TADA! you now have a url you can hit to trigger your lambda function.
Remember you'll need the query string ?url=YOURURL&key=YOURKEY at the end of it to work as expected.

Chrome Extention

This will be pretty simple, only 2 files. However, it does involve putting your chrome extension in developer mode which does have some security implications, so be warned.

1) Download the repo at https://github.com/sselfridge/send-it

Zip here: https://github.com/sselfridge/send-it/archive/master.zip

2) Put the unzipped files somewhere they can live going forward, they will be executed from here.

3) You only need to edit script.js, but you can modify manifest.json if you'd like to name it something else besides 'send it!'

4) In script.js add in your key and AWS endpoint

  const AWS_API_ENPOINT = "https://123456789.execute-api.us-west-2.amazonaws.com/PuppyStage";
  const KEY = "correcthorsebatterystaple";

5) Open Chrome and go to the 'manage extensions' page. You can get to it by right-clicking on any extension icons you have and click 'manage extensions' there.

6) click the 'developer mode' toggle in the top right

7) click 'load unpacked' in the new menu on the top left

8) select your folder

You're done! Go to any image in chrome and right-click on it, you should see the 'send it' option there and clicking it will send that URL to your number.

Remember you'll have to change/add more subscriptions in the AWS SNS console depending on which numbers you want to send it to.

Further Work

This does leave some things to be desired.

There's no feedback if things stop working at any point.
No icons for chrome extension
Chrome warnings about dev mode on startup. Could be fixed by publishing to the chrome store, which I've done personally, but the AWS API endpoint is hardcoded since I didn't add the UI elements to prompt for it.

Cheers and happy puppy-ing!

Fun with BASH Pt: 2 Aliases

Sirclesam — Mon, 03 Jun 2019 14:00:14 +0000

Pt 1: https://dev.to/sirclesam/fun-with-bash-pt-1-scripting-51l9

This one will be short, which makes sense in context.

Another way to save precious keystroked when working in the terminal is to use bash aliases. My main use for this is to get to project directories that I access frequently.

If you read my previous post about writing bash scripts you may have thought to try something like this, but realized after the script executes that you're still in the same directory. This is because in .sh scripts cd just changes the directory in the context of the script and not your active shell, luckily alias can help with this.

Once again we're going to be editing our bash profile file in our home dir. For most BASH shells on linux this will be ~/.bashrc however because apple with the stock OSX terminal it is ~/.bash_profile.

For a while, I've been doing daily hack-hours to practice algorithm solving, pulling from a daily updated repo that has new problems in it every day. In order to interact with the scripts I need to be in their directory which means typing:

cd hack-hour/challenges/

which even with tab correction still equals 5 keystrokes every morning. Ain't nobody got time for that!

open up your bash profile and insert the following:

alias hh="cd ~/hack-hour/challenges"

Go open a new terminal (has to be new, remember the profile settings get added when a terminal is opened) and try it!

TAH DAH!!

Originally that was going to be all for this article, but I learned a new BASH trick that I can rope back into this so you get that too.

I just learned you can cd - to go back the previous directory you were in, pretty neat but got me thinking about some alias work I'd done in college when we lived in the terminal.

pushd is a less well-known sibling of cd. It does the same thing but as its name might have suggested it does a push, and this is on to a directory stack. The benefit of this is you can do a popd to traverse backwards through the stack.

Another thing to note about aliases, that this demonstrates, is they get executed before anything on your PATH environment variable, so if you add this to your profile:

alias cd="pushd"

now anytime cd is used it will call pushd instead and you can utilize popd to go back in your directory history, if cd - doesn't get the job done!

That's it for now,
cheers

Fun with BASH Pt:1 Scripting

Sirclesam — Thu, 11 Apr 2019 04:11:38 +0000

Fun with BASH

Part 1: Scripting

Ever find yourself typing out the same long command line groups over and over?

BASH scripting can help!

Let's say you want to want to commit and push to your git repo in one command instead of doing it separately.

(Note on code examples: >$ will be used to indicate the terminal and --> the output from entering that command)

Let's get started:
Open your terminal - we're going to be working your root directory. Create a new file. the .sh extension is usually used on BASH scripts

>$ touch commitpush.sh

Before we edit the script we're going to need to make this file executable. Because right now if we try to execute it we get an error.

>$ ./commitpush.sh --> bash: ./commitpush.sh: Permission denied

To do this we use the chmod command which stands for change-mode. We're going to call it on our script with the flag a+x. This will make this file executable for all users. see the man page for chomod for other options. If you want to remove executability use the flag a-x

>$ chmod a+x commitpush.sh

One last thing before we can start on the script, we need to find out where BASH is on your computer so we can tell the script where to look to execute itself.

>$ whereis bash --> /bin/bash

Note my OSX system has bash in the root bin/ folder but yours might be different.

Time to start editing the script file!

First is to use that info we got from whereis to tell the script where to look to execute itself. This is done with the #! character. Adding the following to your file

#!{yourBASHPATH}
echo This is Working!!!

Now you can execute this script

>$ ./commitpush.sh ---> This is Working!!!

Nice but doesn't help us with much, let's change it to actually have some functionality.

#!/bin/bash
git commit -a
git push

Note using the -a flag on git commit will only commit changes to files that have already being tracked by git, you'll still need to git add any new files.

Well now have a script to save us typing two lines every time, but it's not easy to call it. You're probably used to running bash commands by just typing their name, but if you've noticed every time we've run this script we've prefaced it with ./

This is because as a security measure BASH won't let you execute just any file by name, even if you're in the directory.

>$ commitpush.sh --> -bash: commitpush.sh: command not found

There's another inconvenience issue as well - while a bash script executes in whatever the current directory is, you will still have to reference its current location to execute it. If you're several layers deep this can be irritating.

Let's say your git project is located in ~/codesmith/gitRepos/myProject/ in order to run the script in your home directory you'd have to enter:

../../../commitpush.sh

Luckily there's a built-in system we can use, the $PATH environment variable. You can see your using the echo command:

>$ echo $PATH --> /usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin

Each of these directories is where BASH will look in order to execute a command. So one thing we can do is put our script in one of these directories. I recommend the /usr/local/bin since its less likely to interfer with any built in system commands.

We can move it in using the move (mv) command.

>$ cd -Gets us back to the home directory
>$ sudo mv commitpush.sh /usr/local/bin - moves script to the local bin.

The directory we're putting it in is protected so you'll need to use sudo and enter your password to get it.

Now you can just type commitpush.sh from any directory where you have an active git repo and it will take care of the rest!

One thing to note is using this method means your commit message will open in vi. Get into 'INSERT' mode by hitting the i key then type your message. Exit and save in vi by hitting '[Esc] : w q [enter]'

If you don't like this, then read on and I'll cover how to do this without messing with vi.

Pt 2 - Checking for errors and varibles

So this works in the ideal case, but what if there are errors with your commit? We don't want to push when there is something wrong so this should have some logic keep that from happening. We can do this in our script with exit codes and some conditionals.

Exit codes

Every command that runs in BASH is supposed to return an exit code. This is 0 if everything went as expected and not 0 in the case of anything else. Usually, it's 1 but non-zero is the important part.

This is stored in the BASH varible $? and you can see it by using the echo command.

Success example

>$ cp cp.sh commitpushCOPY.sh
>$ echo $? ----> 0

Failure example

>$ cp MADEUPFILE.sh commitpushCOPY.sh  ---> No such file or directory
>$ echo $? ----> 1

Something that can be tricky here is that 'echo $?' its self is a command so it will set the exit code when it runs

>$ cp MADEUPFILE.sh commitpushCOPY.sh  ---> No such file or directory
>$ echo $? ----> 1
>$ echo $? ----> 0

Now to put it in our script.

#!/bin/bash
git commit -a 

if [ $? = 0 ] 
then
  git push
fi

Note the how instead of curley braces this uses fi to end the block. Let's add some output to make this more user friendly and to show how the if then/else works in scripting. The comparison is done with a single = operator not the usual === you've been used to in JS.

#!/bin/bash
git commit -a 

if [ $? = 0 ] 
then
  echo 'Commit success, pushing'
  git push
else
  echo 'Commit failure, aborting push'
fi

Now at least it will be a little more robust and not push anything when we don't expect it to.

But there's still one annoying thing this script does and that's forcing us to enter our commit message in vi and then try to remember how to write-quit vi.

The final entry here will be how to avoid that using parameters.

You're already used to using these. Anything that comes after the command you're using is a parameter. This is commonly flags -a --save or file names that the program needs to use.

using them in a bash script is pretty straight forward. Each space separated value will come in as a bash variable with a number following it.

Script foo.sh

#!/bin.bash

echo $1
echo 'Line of text'
echo $2
echo 'More text'
echo $3
echo 'and even more text'

Running the above script we get

>$ ./foo.sh bar baz
bar
Line of text
baz
More text

and even more text

See how bar and baz are listed and there's an empty line since there is no $3 argument provided.

So using this and the -m flag with git commit we can avoid vi.

#!/bin/bash
git commit -a -m $1

if [ $? = 0 ] 
then
  echo 'Commit success, pushing'
  git push
else
  echo 'Commit failure, aborting push'
fi

Now you can commit and push your change with one line!

`>$ commitpush.sh 'Commit and push progress on the current branch'

You'll have to put quotes around your message otherwise your commit message will just be one word.

If you want to avoid this - add in error checking that will abort the entire script if more than one parameter is provided.

Happy coding!!!

Pt 2: Aliases
https://dev.to/sirclesam/fun-with-bash-pt-2-aliases-2imj