Forem: Josue Bustos

Post Messages To Slack Using AWS Lambda Function URLs

Josue Bustos — Sun, 01 May 2022 00:12:25 +0000

Introduction

This tutorial will show you how to post messages to Slack apps using their Incoming Webhook API and the AWS Lambda Function URL.

What is an AWS Lambda Function URL?

A function URL is a dedicated HTTP(S) endpoint for your Lambda function. You can create and configure a function URL through the Lambda console or the Lambda API. Lambda automatically generates a unique URL endpoint for you when you make a function URL. -- AWS docs.

Learn more about AWS Function URLS here

What is a Slack Incoming Webhook?

Incoming Webhooks are a simple way to post messages from apps into Slack. Creating an Incoming Webhook gives you a unique URL to which you send a JSON payload with the message text and some options. You can use all the usual formatting and layout blocks with Incoming Webhooks to make the messages stand out. -- Slack API Docs

Learn more about Slack Incoming Webhooks here

Prerequisites

To follow along, you will need the following:

A AWS account (create one here)
AWS CLI installed and configured. Set up instructions here
A Slack account (create one here)
AWS Lambda Function (fundamentals)
AWS IAM Roles, Policies (fundamentals).
Comfortable executing terminal commands without GUI.
Comfortable using and debugging Node.js and JavaScript.

Cool Idea 💡: In the future, you can use this example in an AWS SAM or AWS CDK project. Like this one AWS CDK Node.JS: Hello World

Okay, let's get started!

Create Slack App Channel

First, you want to predetermine which Slack app channel to use to receive incoming messages. For example, you can use an existing channel like #random or create a new channel. For this example, I will be using the #my-test-app naming convention. See the image below for reference.

Create a Slack App

To receive messages from external applications, say from your website or a mobile application, you must configure your Slack "API app" settings.

Sign in to your Slack account and navigate the Slack API portal "Your Apps" page. Copy-paste this link to jump there now: https://api.slack.com/apps.

If this is your first time creating a Slack account Your Apps list will be empty. Otherwise, you will see a list of your API apps.

Next, click on the Create New App or Create an App green button to open the "Create an app" modal window.

Select the From scratch option.

In the App Name, type your app name. I use "Send Me Tacos" for this example, but you can choose anything you like. :)

Next, use the dropdown menu to locate the workspace where you want to send messages. The workspace is the name of the account you created. In this example, I named it "Taco Paradise".

Can you tell I'm thinking about yummy food?

When done, click on Create App. This last step will take you to a new page. See the image for reference.

After creating your new app, stay on the same page and scroll down to locate the Incoming Webhooks link on the left menu list. Click on the link to display the webhook configuration page. Notice how next to the words "Activate Incoming Webhooks" is set to off.

Click on that switch to enable it. It should turn green and display the text "On."

Well done!

Create a Webhook

Finally, click on the Add New Webhook to Workspace button to create a webhook URL. This step opens a new window.

In the new window, notice where it says, "Test App requires a channel to post to as an app" click on the dropdown menu and select the channel you want to send your messages.

Note: We referenced this step at the beginning of the tutorial. In this example, I chose #my-test-app.

You can now take your new webhook URL for a spin. Using your preferred terminal application or API client, Copy-paste YOUR sample curl request into the API client or terminal and execute the command/s.

Note: Replace the webhook URL with yours.



curl -X POST -H 'Content-type: application/json' --data '{"text":"Hello, World!"}' https://hooks.slack.com/services/5CKKM62NX5J/8G8XMGQ3RXM/aadCZ8act32sLJ7dgaC8HLrx

After executing the command, navigate back to the Slack app, web, or mobile and notice the new message; "Hello, World!".

Tada!
SO COOL!!!

You may not notice it right away, but two things happened. 1) Your incredible message was displayed in the Slack app, and 2) your Slack API app is now integrated into the Slack app.

Cool Idea 💡 : You can use Postman and Insomnia API clients to test and prototype your Slack webhooks and AWS Function URLs. ;)

You can stop here and call it a day, but continue the next section if you want to flex.

Create an AWS Lambda Function URL

Right then!

Let's take this tutorial to the next level. In this next section, I will show you how to create and configure an AWS Lambda Function URL so you can use the Slack Incoming Webhooks.😃

Also, we're going to use the AWS command-line interface to create AWS identity permission called roles and policies to allow the function URL to work.

If you need a refresher, visit the AWS IAM docs here.

Ready!? Let's go!

Create AWS IAM Role

First, we need to access your ARN, which is AWS specific formatted string. Similar to this one:

arn:aws:iam::123456789123:user/username

And to access that, we can execute the following AWS CLI command in the terminal like so:

Note: Change Paulo to your user name



$ aws iam get-user --user-name Paulo

The response should look similar to the JSON text below. Save your text somewhere to reference it later, or you can rerun the command.



$ {
    "User": {
        "UserName": "Paulo",
        "Path": "/",
        "CreateDate": "2019-09-21T23:03:13Z",
        "UserId": "AIDA123456789EXAMPLE",
        "Arn": "arn:aws:iam::123456789012:user/Paulo"
    }
}

Attach AWS Policy to IAM Role

Next, create a file called trust-policy.json



// trust-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Pause here and change the role name function-url-role to something else or keep it until you create another one.

Once you're ready, open your terminal or command prompt, copy-paste the command below, and press enter.



$ aws iam create-role --role-name function-url-role --assume-role-policy-document file://trust-policy.json

A successful response will return some more JSON text.

This next step will attach an AWSLambdaBasicExecutionRole policy to your newly created IAM role. This policy gives you the basic user permissions to run your function.

Go ahead and copy-paste and execute the command below into your terminal app.

Remember to replace your function role name with yours. In this example its function-url-role.



$ aws iam attach-role-policy --role-name function-url-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

Create AWS Function URL

In this section, you will create and configure your AWS Lambda Function and enable the new function URL feature with some basic settings.

First, we need access to the ARN role string. To do that, execute the AWS CLI command below.



$ aws iam get-role --role-name function-url-role

The response output should return some JSON similar to the text below.

Pause for a second and locate your the "Arn" string value which similar to this text arn:aws:iam::123456789012:role/my-function-url and save it somewhere for later.



// terminal JSON ouput
{
    "Role": {
        "Path": "/",
        "RoleName": "my-function-url",
        "RoleId": "AIDA123456789EXAMPLE",
        "Arn": "arn:aws:iam::123456789012:role/my-function-url",
        "CreateDate": "2022-04-16T22:32:36+00:00",
        "AssumeRolePolicyDocument": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Principal": {
                        "Service": "lambda.amazonaws.com"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        },
        "Description": "Allows Lambda functions to call AWS services on your behalf.",
        "MaxSessionDuration": 3600,
        "RoleLastUsed": {
            "LastUsedDate": "2022-04-30T00:29:38+00:00",
            "Region": "us-west-2"
        }
    }
}

Prepare Your Files

Before creating an AWS Lambda Function, you need to prepare some code, execute a few AWS CLI commands and finally deploy your project for live testing. For this example, we're going to use JavaScript for Node.js.

First, create a file called index.js, then prepare the file for editing. Use the command below with your preferred terminal app, or you can manually modify it.



$ touch index.js && vim index.js

Next, copy-paste the following JavaScript code into the vim edit session in the terminal or use your preferred code editor. Make sure to replace the "string" where it says <-- YOUR WEBHOOK GOES HERE --> with your Slack API webhook URL.

For example, from this:

path: '<-- YOUR WEBHOOK GOES HERE -->'

To this

path: '/services/T02S60H1F0Q/B03DH5L14S1/CPHv2eu0ctGgB9g99DNZiNCi'



// index.js
const https = require('https');

const postRequest = (a) => {
    const payload = { "text": `${a}` };

    const data = JSON.stringify(payload);

    const options = {
        hostname: 'hooks.slack.com',
        path: '<-- YOUR WEBHOOK  GOES HERE -->',
        port: 443,
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
            'Content-Length': data.length
        }
    };

    return new Promise((resolve, reject) => {
        const req = https.request(options, res => {
            let rawData = '';

            res.on('data', chunk => {
                rawData += chunk;
            });

            res.on('end', () => {
                resolve({
                    statusCode: 200,
                    body: `${rawData}`
                });
            });
        });

        req.on('error', err => {
            reject(new Error(err));
        });

        req.write(data);
        req.end();
    });
};

exports.handler = async (event) => {

    let body = JSON.parse(event.body);
    const result = await postRequest(body.text);

    const response = {
        statusCode: 200,
        body: result,
    };
    return response;
};

Finally, zip your files using the command below or manually.



$ zip function.zip index.js

You create an AWS Lambda Function using the AWS CLI in the following sections.

Create AWS Lambda Function

Pause for a second here. Think of a name for your new function. In this example, I'm using my-url-function.

Remember that ARN string you saved earlier? Replace the ARN string with yours.

For example, from this:

--role [YOUR ARN GOES HERE]

To this

--role arn:aws:iam::123456789012:role/my-function-url

When you're ready, copy-paste and execute the following command in the terminal:



$ aws lambda create-function \
    --function-name my-url-function \
    --runtime nodejs14.x \
    --zip-file fileb://function.zip \
    --handler index.handler \
    --role [YOUR ARN GOES HERE]

The output should return an extended JSON response with your AWS Lambda Function details.

You can verify if your lambda function was created by using the following command in the terminal.



$ awd lambda get-functionn --function-name my-url-function

Enable AWS Function URL

Traditionally, you would have to go through more than a dozen steps to create a simple endpoint using AWS Lambda, API Gateway, and rightfully so when creating secure endpoints, but now there's a better way.

Execute the following command, and remember to replace your function name with yours.

From this:

--function-name YOUR-FUNCTION-NAME \

To this:

--function-name my-url-function \



$ aws lambda create-function-url-config \
    --function-name YOUR-FUNCTION-NAME \
    --auth-type NONE \
    --cors '{"AllowOrigins": ["*"],"AllowCredentials": false}'

Note: For this demo, the link is public. You're responsible for securing your endpoints in all of your production environments.

Test Your AWS Function URL

Now for the moment you've been waiting for. Use the following command in your terminal and execute.



$ curl -X POST \
    '<YOUR FUNCTION URL GOES HERE>' \
    -H 'Content-Type: application/json' \
    -d '{"text": "Feed me Seymour!"}'

A successful response should return some JSON text similar to the one below.



$ {"body":"ok","statusCode":200}

If you are successful, you should see another message in the Slack app channel with the text "Feed me, Seymour!".

Conclusion

AND THAT'S IT!

I hope you leveled up some of your AWS Cloud Serverless skills and enjoyed this tutorial.

I appreciate you getting this far, and I hope to see you next time!

AWS Lambda: Send a Message with Discord Webhooks

Josue Bustos — Sat, 25 Dec 2021 08:02:07 +0000

Introduction

Learn how to send a message from AWS Lambda to a Discord channel using Discord's built-in Webhooks function. This tutorial will show you how to configure the AWS Lambda and a Discord webhook endpoint to send messages to a specific Discord channel.

What is AWS Lambda?

Lambda is a compute service that lets you run code without provisioning or managing servers.
Lambda runs your function only when needed and scales automatically, from a few requests per day to thousands per second.
You can run code for virtually any type of application or backend service.
Learn more about AWS Lambda here

What is a Discord Webhook?

Discord's built-in Webhooks function as an easy way to get automated messages and data updates sent to a text channel in your server. Learn more about webhook here )
Tip: Discord messages have "Rate Limits, meaning you can only send a specific number of messages, or requests to be exact, per second. You can learn about it here

Getting Started

This tutorial assumes you are familiar and comfortable utilizing the terminal, navigating the file system without a GUI, and navigating the AWS Console. To take full advantage of this tutorial, review the list of prerequisites below.

Prerequisites:

Access to AWS account
Access to Discord account
Python installed on your system
Familiarity with Python programming

Create a Discord Server

We will first create a Discord server and use the default Discord channel to prepare incoming messages.

If you already have a discord server created and a channel ready, you can skip this step and jump to the "Prepare AWS Lambda Layer" section.

Navigate to the Discord website or open the Discord desktop app to access your account. Next, create a discord server by clicking on the green button with the big plus symbol.

On the Create a server window, click the Create My Own button.

On the following Tell us more about your server window, click on the For me and my friends button.

Finally, on the Customize your server window, you can change the server's name in the Server Name field or click on the Create button to complete the server setup.

Create a Discord Webhook

In this example, I will use the default channel to create my webhook url, but you can create another channel if you desire.

Locate the Edit Channel button, which looks like a "Gear" icon on the left-hand side of the Text Channels pane. Click on the "Gear" icon to display the settings window.

Next, click on the Integrations button to display Integrations settings. Then click on the Webhooks button to open a new webhooks window.

You can leave everything as is or if you have more than one channel, use the drop-down menu to select another channel. You can also take this time to change the title of the channel.

And finally, click on the Copy Webhook URL button, which copies the string to your clipboard. Next, close the window by clicking on the "X" button in the top right corner.

And that's it! Move on to the next section to configure your AWS Lambda.

Prepare AWS Lambda Layer

To utilize Python packages in an AWS Lambda project, you must first upload a zip file containing all your Python packages to an AWS Lambda Layer. I will show you how to set that up in the following few sections.

Let's begin.

Create local directory

We're only installing one package called discord-webhookto keep our project simple. For more code examples and usage visit the link here

Next, create a directory/folder and give it a unique name or open a terminal and type the command below like so:



$  mkdir my-project

Download Python packages

For this next step, you will need to access the Terminal window. If it's not already open, open the Terminal window and type the following command to change the directory and install the discord-webhook package in the current directory.



$ cd ~/Desktop/my-project && pip3 install -t . discord-webhook

The -t flag forces Python to install all your packages in the current folder by "targeting" the current working directory/folder. In our case, it's the current directory indicated by the period symbol "." located after the "-t" and "discord-webhook" is our Python package.

Next, remove unnecessary files by typing the command below like so:



$ rm -r *dist-info __pycache__

Suppose you see a warning like the one below. It just means that a specific folder doesn't exist. Some systems include this folder when downloading python packages.



rm: __pycache__: No such file or directory

At the time of this writing, the current version of discord-webhook is 0.14.0.

Compress and Zip directory

You can zip the folder manually or use this handy terminal command by typing the following like so:



$ zip -r -q ~/Desktop/my-project.zip .

Configure AWS Lambda Layer in the cloud

Before launching and executing our main program from the AWS Lambda console, we need to set up our AWS Lambda Layer containing the Python packages you download earlier.

Create AWS Lambda Layer

Open a web browser and sign in to your Amazon Web Services console. Next, locate the search bar, type "lambda," then click on the Lambda link to navigate the AWS Lambda Function web page. See the image below for guidance.

On the sidebar on the left-hand side, locate and click on the Layers link to jump to the Layers page. Next, find and click on the Create layer button to initiate the "AWS Lambda Layer" creation process. See the image below for guidance.

Upload Zip File

Use the list and image below to help fill out the form.

1) Name: Discord-Layer
2) Description: Write description for your layer
3) Select: Upload a .zip file
4) Upload file: my-project.zip
5) Select architecture: x86_64
6) Select runtimes: Python 3.9
7) Click Create button

Excellent! Now you're ready to create your AWS Lambda Function!

Create AWS Lambda Function

On the left-hand sidebar, locate and click on the Functions link, then on your right-hand side, locate and click on the Create function button; this will open a new window.

By default, the Author from scratch is selected. Leave it as is and scroll down to fill out the form. You can also use the image below to guide you.

1) Function Name: Discord-Webhook
2) Runtime: Python 3.9
3) Architechture: x86_64
4) Click Create function

You can leave the rest of the settings and wait a moment for the AWS Function configuration process to finish.

Import Python modules

When you arrive at your AWS Function page, scroll to the bottom of the page, locate and click the Add a layer button.

1) Layer Source: Custom layers
2) Custom layers: Discord-Layer
3) Version: 1
4) Click Add

Configure Test Event

Before we can execute our AWS Lambda Function, you need to configure a Test event.

1) Saved Test Events: MyDiscordEvent
2) Click Create button

Import Python Modules

Now for the fun stuff!

Go ahead and copy-paste the code below into the cloud nine text editor. Make sure to replace this with your Discord channel url webhook.



webhook = DiscordWebhook(url="<replace_with_your_hook>")

embed = DiscordEmbed(

    title="Taco Love",

    description="You deserve some taco love today!",

    color="03b2f8")

embed.set_image(url="https://cdn.dribbble.com/users/545781/screenshots/3157610/happy-taco.jpg")

webhook.add_embed(embed)

webhook.execute()

def lambda_handler(event, context):

<span class="k">return</span> <span class="p">{</span>
    <span class="sh">"</span><span class="s">statusCode</span><span class="sh">"</span><span class="p">:</span> <span class="mi">200</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">body</span><span class="sh">"</span><span class="p">:</span> <span class="p">{</span><span class="sh">"</span><span class="s">message</span><span class="sh">"</span><span class="p">:</span> <span class="sh">"</span><span class="s">Hello World</span><span class="sh">"</span><span class="p">}</span>
<span class="p">}</span>

Send Discord Message

Now, for the moment of truth!

Open your discord channel and click on the orange Test button.

If everything was done correctly, you should see a nice happy taco!

conclusion

Recap:

You created and configured a AWS Lambda Function
You created and configured a Discord Webhook
Implemented a Discord API using Python programming language

--

If you've gotten this far YOU. ARE. AWESOME!

At times, working with AWS Console can be a bit discouraging and a bit scary. I hope this tutorial gives you a bit more confidence and more courage to continue pursuing code and any of your cloud certifications!

Until next time,

Stay AWSome!

Samsung Galaxy Watch: Controlling WebXR 3D Objects In Real-Time

Josue Bustos — Mon, 21 Jun 2021 02:58:26 +0000

Introduction

In this conceptual playground, I demonstrate how you can control objects in 3D space using A-Frame WebXR, Node.js. Socket.io, and a Samsung Galaxy Watch.

Prerequisites

To implement the web techonloiges mentioned you need an intermediate to advance HTML, JavaScript practical knowledge. The list of web technologie are as follows:

Software

AR/VR capable broswer
Socket.io
Node.JS
A-Frame

Okay, let's jump in!

Setting up A-Frame

A-Frame is primarily HTML and JavaScript. So all you need to get started is a basic text editor.

Open your favorite text editor, create, edit, and then copy-paste the following code into index.html.

<!-- index.html -->
<html>
  <head>
    <!-- A-Frame Script -->
    <script src="https://aframe.io/releases/1.2.0/aframe.min.js"></script>
  </head>
<body>
    <a-scene>
        <a-box position="-1 0.5 -3" rotation="0 45 0" color="#4CC3D9"></a-box>
        <a-plane position="0 0 -4" rotation="-90 0 0" width="4" height="4" color="#7BC8A4"></a-plane>
        <a-sky color="#ECECEC"></a-sky>
    </a-scene>
</body>
</html>

You can also visit the A-Frame website and explore other sample projects.

Not sure if your browser is capable of displaying WebXR content? Not to worry, visit this link to the "Does my browser support WebXR" web page.

Accesing Wearable Device Sensors

A Samsung Galaxy Watch can be either a wearable Web application, a Native or Hybrid derived application. My example is a Web application, basically a Web site stored on a wearable device.

To access sensor data, you implement a few lines of code. For example, the following sample JavaScript code below gives us access to Gyroscope sensor data:

var gyroscopeRotationVectorSensor = tizen.sensorservice.getDefaultSensor("GYROSCOPE_ROTATION_VECTOR");

function onGetSuccessCB(sensorData){
  console.log("Get the gyroscope rotation vector sensor data");
  console.log("x: " + sensorData.x);
}

function onerrorCB(error){
  console.log("Error occurred");
}

function onsuccessCB(){
  console.log("Sensor start");
  gyroscopeRotationVectorSensor.getGyroscopeRotationVectorSensorData(onGetSuccessCB, onerrorCB);
}

gyroscopeRotationVectorSensor.start(onsuccessCB);

You can view a complete list of available device APIs for the Samsung Galaxy Watch here.

Moving 3D Objects In Real-Time

And finally, to remotely control objects in 3D space, you need to host and configure your Node.js server to allow socket.io to open a bidirectional real-time connection. You can use the following sample code to get started.

// Initiate a Socket,io connection for Node.js
const io = require('socket.io')(80);
const cfg = require('./config.json');
const tw = require('node-tweet-stream')(cfg);

tw.track('socket.io');
tw.track('javascript');
tw.on('tweet', (tweet) => {
  io.emit('tweet', tweet);
});

Live Demo

You can watch a demo of these technologies working together on youtube.

Thank you!

Screen Sharing Android Devices on macOS + React Native Demo

Josue Bustos — Mon, 14 Jun 2021 23:36:17 +0000

Introduction

We know that iPhones have the advantage of sharing files and their screen to macOS. So what's a good alternative for Android?

In my opinion, as a developer, the best out-of-the-box choice is the open-source CLI tool called SCRPY — one of the sharpest tools in my shed for mobile app development.

This tutorial will show you how you can mirror your Android device screen to your macOS laptop. Don't like macOS? Not to worry. The tool supports Linux and Windows too.

Furthermore, to complement our newly installed handy dandy tool, I will create a React Native "Hello World" app, deploy it to an Android device, and see our new tool work its magic.

Okay, then. Let's get started!

Prerequisites

This tutorial assumes you are familiar and comfortable navigating, modifying, using the terminal, and executing CLI commands, and to follow along, please have the following software installed on your host machine before moving forward:

Homebrew
Node.js
Android Studio
Android Device

Note: Make sure Developer Mode is enabled on your Android device. It will allow you to connect to your laptop and much more. If you haven't prepared this step, visit the Android documentation here, then come back when you're ready.

Install scrcpy

First, open your preferred terminal and install the scrpy by typing the following command, like so:



$ brew install scrcpy

For React Native development, install Watchman. This utility keeps track of any changes you make to your files, builds, compiles your code, and immediately deploys those changes on your device without breaking a sweat!



$ brew install watchman

As of this writing, this utility does not run in detached mode, which means you have to open a new tab to continue multitasking.

Go ahead and open a new tab, and now you can launch the screen sharing utility by typing:



$ scrcpy

Explore more CLI combinations by visiting the scrpy Github main page.

If you're a pro with React Native then, you can skip the following steps and enjoy the rest of your day. If not, stick around and make some magic! :)

Create a React Native project

Return to your original project terminal window or tab. Next, type the following command to create a React Native app:



$ npx react-native init SampleProject && cd SampleProject/

Deploy to device

To install and launch your app on the device, type the following command:



$ npx react-native run-android

This command will open an extra tab or window for Metro. More information explaining what it is here, but not to worry, let it do its thing and see your newly created app get installed onto your device like magic!

AND THAT's ABOUT IT!

Not too bad for a hard day's work, ey!? Grabs some coffee, some libations, and bask in your success!

Working With DynamoDB, AWS NoSQL Workbench, and Node.JS

Josue Bustos — Mon, 14 Jun 2021 03:50:18 +0000

Introduction

In this tutorial, I will show you how to set up a locally-hosted DynamoDB server, use the AWS NoSQL Workbench to insert data into DynamoDB, and finally, create a simple Node.JS project that will query sample data provided by AWS NoSQL Workbench.

Prerequisites

This tutorial assumes you're comfortable executing terminal commands, navigating, and modifying the macOS and Ubuntu Linux file system.

My setup is a hybrid environment consisting of a Host, macOS Catalina, and a Guest Ubuntu VM instance. But You can set up everything on one host, macOS, Ubuntu, or Windows.

To follow along, you will need the following already installed:

On Ubuntu (Guest) or Host:

On MacOS (Host):

Ubuntu 20.04.2 VM instance

Okay, let's get started! :)

Install AWS NoSQL Workbench

Let's get the simple stuff out of the way. Navigate to the AWS DynamoDB Developer page and download the AWS NoSQL Workbench for your Operating System.

After downloading the installation file, follow the onscreen instructions to install NoSQL Workbench.

Install DynamoDB

Docker and Docker Compose will create and manage the DynamoDB server container and install all the required software packages and dependencies.

Open your preferred terminal app and type the following command to create a folder, change directories and create a YAML file in one swoop, like so:


 bash
$ mkdir ~/dynamodblocal && cd ~/dynamodblocal && touch docker-compose.yml

Next, copy-paste the following YAML code into the docker-compose.yml file.




# docker-compose.yml

version: '3.8'
services:
  dynamodb-local:
    command: "-jar DynamoDBLocal.jar -sharedDb -optimizeDbBeforeStartup -dbPath ./data"
    image: "amazon/dynamodb-local:latest"
    container_name: dynamodb-local
    ports:
      - "8000:8000"
    volumes:
      - "./docker/dynamodb:/home/dynamodblocal/data"
    working_dir: /home/dynamodblocal

Finally, launch the DynamoBD Server by typing the following command in the terminal:


 bash
$ docker-compose up

The first time you execute this command, it will take a few minutes to get the server up and running. The next time after that, it should be instant.

Now, if you see an output similar to the one below. That means you have successfully installed and launched a DynamoDB Server!



dynamodb-local    | Initializing DynamoDB Local with the following configuration:
dynamodb-local    | Port:       8000
dynamodb-local    | InMemory:   false
dynamodb-local    | DbPath:     ./data
dynamodb-local    | SharedDb:   true
dynamodb-local    | shouldDelayTransientStatuses:       false
dynamodb-local    | CorsParams: *
dynamodb-local    |

To quickly shut down or stop the server, press:



Ctrl + C

Insert Data Into Your DynamoDB Server

Before we can perform requests to the database from inside Node.js, we need to insert data. To do that, we're going to leverage AWS NoSQL Workbench GUI and connect to our recently launched DynamobDB server.

Choose a Model

First, open/launch the AWS NoSQL Workbench.
On the left sidebar, locate and click on Visualizer.
Click on the dropdown menu and select AWS Discussion Forum Data Model.

This model includes three tables for you to explore: Forum, Reply, and Thread.

Next, click on the Commit to Amazon DynamoDB button

When the popup opens, click on the tab furthest to the right that says Add a new DynamoDB local connection.
Then, click on the Commit to connect to your local database.
You can choose whatever name you want for Connection name field.

This step does three things. First, it creates a connection, inserts all three tables into your database, and opens a new window or view, called Operation builder, that displays all your databases.

Finally, Click the Open button and Voilà!

Now we're ready to make requests to the database in Node.js!

Query Data With Node.js

To query data from DynamoDB in your Node.js project, you use the AWS JavaScript SDK for Node.js. So, Let's get to it...

Open your preferred terminal app, create a directory, change directories, and initialize it to install npm packages. We can do this in one swoop like so:



$ cd ~/ && mkdir my-project && cd my-project && npm init -y

While we're here, install DynamoDB specific packages by typing the following command:



$ npm i @aws-sdk/client-dynamodb

Next, create a file called index.js :



$ touch index.js

Copy-paste the following code into the index.js file:



// index.js
const { QueryCommand } = require('@aws-sdk/client-dynamodb');
const REGION = "eu-west-2"; //e.g. "us-east-1"

// Create an Amazon DynamoDB service client object.
const ddbClient = new DynamoDBClient({
    region: REGION,
    endpoint: 'http://localhost:8000'
});
// Query Parameter to retrieve data from DynamoDB
const params = {
    TableName: "Forum",
    ScanIndexForward: true,
    ConsistentRead: false,
    KeyConditionExpression: "#0b290 = :0b290",
    ExpressionAttributeValues: {
        // Attribute Name
        ":0b290": {
            "S": "AWS Data Pipeline"
        }
    },
    "ExpressionAttributeNames": {
        // Partition key
        "#0b290": "ForumName" 
    }
};

// a "run" function 
const run = async () => {
    try {
        const data = await ddbClient.send(new QueryCommand(params));
        data.Items.forEach(function (element, index, array) {
            // Display data in the console
            console.log(element);            
            return data;
        });
    } catch (err) {
        console.error(err);
    }
};

run();

Now, let's see if this works. First, open a terminal and type the following command to execute the run() function, like so:



$ node index.js

Your output should look like this:



{
  Threads: { N: '19' },
  Category: { S: 'Amazon Web Services' },
  Messages: { N: '9' },
  Views: { N: '500' },
  ForumName: { S: 'AWS Data Pipeline' }
}

Phew! If you've gotten this far, you're a champ! AND you're pretty serious about AWS Cloud Engineering and Development. Hats off to you!

There was a lot to unpack in such a short time. However, you can deep dive into some of these practical solutions by jumping on over to the AWS Developer documentation.

Thank you for sticking around and holding on to the end.

Until next time!

HTTPS Localhost For Node.JS

Josue Bustos — Sun, 06 Jun 2021 02:14:28 +0000

Do you need a secure connection for your local Node.js web server? No problem! This tutorial will show you how to create a self-assigned certificate on your local machine using a few CLI commands.

Note: I don't maintain the source code. Specific OS trouble shooting can be found here.

Prerequisites

This guide assumes you're comfortable executing terminal commands, navigating, and modifying the file system.

To follow along, you will need to have the following installed on your host machine:

OpenSSL
Homebrew
Terminal
Node.js
macOS

Not your OS? Not to worry. Linux and Windows MAY require just a tad few more steps. I promise! You can find those steps here.

Let's get started, shall we...

Create A Node.js Project

Create a folder and change directories. We can do this in one line, like so:

$ mkdir sample-project && cd sample-project

Next, create a file inside the project root directory:

$ touch server.js

Copy-paste the sample code below into the server.js file:

// server.js
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

const app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(options, app).listen(3000);

If you launch the server now, it will output an error. Why? Because we have not generated our two pem files referenced in the const options variable.

Create Self-Assigned Certificate

To generate a self-assigned certificate on your host machine, you need to install mkcert using Homebrew like so:

$ brew install mkcert

Generate a certificate locally

Navigate to your Node.js project root directory, open your preferred terminal app, type the following command, and then press Return(enter).

It's essential that you add a localhost string at the end to allow HTTPS to secure your localhost URL.

$ mkcert -key-file key.pem -cert-file cert.pem example.com *.example.com localhost

This command will generate two pem files.

key.pem
cert.pem

If you noticed, the names of these two files reflect the two objects in the const options variable. You project setup should now look similar to the image below.

Verify HTTPS Connection

To verify that everything is working, launch the Node.js server by typing this command in the terminal.

$ node server.js

Next, open a browser, preferably a Chromium OS-based browser, and verify the HTTPS connection in the search bar to the far left has a secure HTTPS icon. See example images below.

Another way to verify your new HTTPS connection is using the web console provided by the browser. Simply navigate to the Security tab.

I will guarantee you that this quick setup will save you hundreds if not thousands of hours googling. I know it did for me!

Note, that this is not a replacement for a real-world secure HTTPS connection and you're expected to implement secure endpoints anywhere and everywhere where security is required and or needed.

I hope you enjoyed this tutorial. Until next time!

AWS CDK Node.JS: Hello World

Josue Bustos — Sun, 30 May 2021 23:04:55 +0000

Introduction

This tutorial will show you how to install the AWS CDK on Ubuntu and deploy your first JavaScript Infrastructure as Code (IAS) to AWS.

Warning: I do not assume any responsibility if you incur any charges. You are responsible for managing your resources in your AWS account.

If you find yourself stuck, I recommend reviewing the AWS documentation to find detailed concepts, definitions, and critical terminology to help you along the way.

AWS CDK Intro

"AWS CDK is a software development framework for defining cloud infrastructure in code and provisioning it through AWS CloudFormation.

You use the CDK to define your cloud resources in a familiar programming language. The CDK supports TypeScript, JavaScript, Python, Java, C#/.Net, and (in developer preview) Go." - AWS Docs.

Today we're going to leverage JavaScript, which you can port to TypeScript at a later time.

Prerequisites

This tutorial assumes you're comfortable, familiar, and have the necessary software installed on your system to follow along.

AWS IAM Credentials
JavaScript
Homebrew
Node JS 10.13.0 or later
Ubuntu OS
macOS
Terminal
Command Line Interface

Note: I will be installing AWS CDK on Ubuntu. Some OS-specific troubleshooting may be required if you run into issues.

Ready!? Let's begin.

Install The AWS CDK

Go ahead and type the following command to begin installing the CDK:

$ npm install -g aws-cdk

Verify that you have installed the CDK:

$ cdk --version

Create A CDK Project

Create a folder where your CDK project will live:

$ mkdir MyTestService

Change directory

$ cd MyTestService

In an NPM fashion, you can create a CDK project using the following command:

$ cdk init app --language javascript

Depending on your host system, it will take a moment to create all the resources necessary to prepare your IaC project. So, sit tight and have some delicious warm coffee.

A successful install will result in the following example output:

✅ All done!
****************************************************
*** Newer version of CDK is available [1.106.1]  ***
*** Upgrade recommended (npm install -g aws-cdk) ***
****************************************************

You can view a list of your stacks by using the following command:

$ cdk ls

example output:

MyTestServiceStack

But we're not done yet!

Add an Amazon S3 Resources

Make sure you're in the root directory of your project. If not, the CDK commands will not function properly.

For this following command, we will add an AWS resource, or within the context Node JS, a package, like so:

$ npm install @aws-cdk/aws-s3

Next, define an Amazon S3 bucket in the stack using the Bucket construct. To do this, locate line 13 or the commented out text and append the following code:

const cdk = require('@aws-cdk/core');
const s3 = require('@aws-cdk/aws-s3');

class HelloCdkStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // The code that defines your stack goes here
    new s3.Bucket(this, 'MyFirstBucket', {
    versioned: true,
    removalPolicy: cdk.RemovalPolicy.DESTROY,
    autoDeleteObjects: true
});
  }
}

module.exports = { HelloCdkStack }

Synthesize an AWS CloudFormation template

$ cdk synth

The "synth" command generates a CloudFormation file. Also, the actual output will extend for several lines. Makes sure to scroll down and explore the generated CloudFormation file.

Resources:
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties: 
    ....

If you received an error like --app is required..., it's probably because you are running the command from a subdirectory. Navigate to the main app directory and try again.

Deploy Your Stack

First, bootstrap your project before deployment, ensuring that AWS is aware of the permissions between resources.

$ cdk bootstrap

AND then you should see a similar output:

 ⏳  Bootstrapping environment aws://965805005461/us-east-2...
CDKToolkit: creating CloudFormation changeset...

Finally, deploy your stack to the AWS Cloud. To do that, type the following command:

$ cdk deploy

As your code is preparing to deploy, it will prompt you to for a yes or no. Type Yes and then press Enter to continue with the deployment process.

While that's doing its thing, you can navigate to the AWS CloudFormation console and see the magic in real-time.

Delete Your Resources

To delete your resources, you just deployed, type the following command:

$ cdk destroy

When prompted to delete all the resources you have created, Type "Y" for yes — otherwise, type "N" for no.

Example prompt:

Are you sure you want to delete: MyTestServiceStack (y/n)? y

Great Job! You just created your first AWS CDK JS APP!

These are industry sought after skills, and I hope it helps you upskill and get you where you need to go in your daily hacking or career!

Until next time!

Visual Studio Code Remote SSH Multipass

Josue Bustos — Sun, 30 May 2021 18:31:58 +0000

This guide will show you how to remote SSH into a Ubuntu VM instance in Visual Studio Code.

Multipass is a platform developed by Canonical to prototype cloud launches locally for free. Learn more about Multipass and its capabilities by visiting multipass.run

This guide assumes you are comfortable using the terminal and connecting to a remote server environment without a GUI. Review the prerequisites to follow along.

Prerequisites

Homebrew for macOS
Visual Studio Code (VS Code)
Terminal, iTerm, or VS Code integrated terminal
Remote SSH extension for VS Code
SSH key

Let's begin.

Installing Multipass on macOS

Open your preferred Terminal app and copy-paste the following command:



$ brew install --cask multipass

Verify the installation was successful:



$ multipass version

A sample output should look similar to this:



$  multipass version
multipass  1.6.2+mac
multipassd 1.6.2+mac

That's it!

Now you can start launching Ubuntu VM instances on the fly with Multipass.

Launch a VM Instance

To quickly launch your first instance, type the following command:



$ multipass launch

// example output
Starting fitting-diplodocus |

Multipass will randomly create an alias name and provision your instance using the latest LTS Ubuntu image.

Using this command also provisions your instance with default resources and a network such as:

Storage: 5 GB
User: Ubuntu
Password: N/A (can be modified)
Network: Bridged (w/ Internet access)

Or you can type a command to view more information about your instance like so:



multipass exec keen-yak -- lsb_release --description

// example output
Description:  Ubuntu 20.04.2 LTS

If you want to list stopped or running instances, type :



$ multipass ls

// example output
Name                    State             IPv4             Image
Imag-Name               Running           191.128.04.24    Ubuntu 20.04 LTS

I personally like the robust horizontal output with more info. Also, make sure to copy the IPv4 Address shown below so you can use it later.



multipass info samcli

// example output
Name:           Image-Name
State:          Running
IPv4:           100.100.04.13
Release:        Ubuntu 20.04.2 LTS
Image hash:     9dd5cb9f73c4 (Ubuntu 20.04 LTS)
Load:           1.01 0.68 0.27
Disk usage:     1.3G out of 4.7G
Memory usage:   138.5M out of 981.3M

And finally, access the Ubuntu instance you just created by typing:



$ multipass shell Image-Name

Deleting your instance

Once you decide you no longer need your VM instance, you can delete it by typing the following command:



$ multipass delete Image-Name

Deleting a VM instance only removes it from queue. Conceptually you can think of deleting a file and sending to the trash bin.

Warning: You will not be able to recover your instance after executing this command.

To completeley remove an instance from disk use the following command:



multipass purge

Visit the Multipass documenation to get familiar with advanced command combinations to create and manage your Ubuntu VM instances.

Now, it's time to SSH into your instance using Visual Studio Code so you can, well, code.

VS Code Remote SSH

To follow along, make sure you have VS Code and the remote SSH extension installed. For detailed instructions and troubleshooting, visit the VS Code docs.

Let's begin...

Add SSH Host

Before we can SSH into our Multipass VM instance, you need to add a new Host in the user's SSH config file. You can directly access the file by locating the directory it's in.



// on macOS
/Users/<user-name>/.ssh/config



// on Linux
/home/ubuntu/.ssh/config

Edit the file by adding or appending these three lines:



Host Alias-Name
  HostName 100.100.04.13
  User ubuntu

What's going on here?

Host: A random name you chose.
HostName: Is the IPv4 address of the VM instance.
User: The user name of the instance.

Add Authorization Key

Below are two links if you need a quick refresher on how to install and create SSH keys.

Install Remote SSH extension tutorial.

How to generate SSH keys.

Log into your VM instance using the Multipass shell command and append your host SSH key to the authorization_keys file in the VM guest instance.

Finally, change to your home directory and create a directory of your choice.

Phewww! We're almost there...

Connect to a VM Instance in VS Code

To SSH into your Multipass VM instance, navigate to the "Open a Remote Window" button on the bottom left corner in VS Code.

This will open a dropdown menu. Click on "Connect Current Window to Host...". Next, select the alias or Host that you created earlier in the guide. VS Code will refresh the current window and establish an SSH connection.

If it's not already open, expand the file explorer on the left pane and click on the green button called "Open Folder". Use the command palette to navigate to the directory you created.

If you see this warning "Visual Studio Code is unable to watch for file changes in this large workspace" (error ENOSPC)" It means Ubuntu doesn't have enough memory to watch file changes. You have to increase the limit to its max 524,288. Refer to the VS Code docs to workaround this issue.

AND that's it! You've successfully SSH into a Multipass Ubuntu instance using VS Code.

Enjoy prototyping the cloud!

Until next time...

Node JS Tizen CLI

Josue Bustos — Sun, 30 May 2021 02:53:16 +0000

If you're looking for the full fledged Tizen CLI visit the Tizen Devleoper website here.

Why a Node JS derived Tizen CLI?

Create an OS-agnostic command-line tool for web developers that can be installed with contemporary IDEs like Visual Studio Code.

And, of course, get familiar with Node JS, low-level APIs that communicate with the OS. Hence the bash scripting nature of the CLI tool, but instead using JavaScript.

How does it work?

The Node JS CLI depends on the Tizen SDK and platform tools to compile, sign, package, and install Tizen Web Apps on the Tizen Emulator and Samsung Watch Device. You can learn more about the Tizen OS platform and dev tools here.

At this moment the current version of the CLI supports only macOS. Possibly with a little more time and TLC it can support Linux and Windows.

Node JS CLI Preview

1) Create a New Project

This commands creates a new Tizen Web App for wearables. Learn more about creating tizen web apps here.

2) Create a Certificate

Allows you to install apps on the Tizen Emulator and on the Samsung Galaxy Watch device.

3) Package your web app into a .wgt file

This is the equivalent to a APK android file that you install on Android devices. You can learn more about the Tizen Web Application architecture here.

4) Launch the Tizen Emulator

5) Debug

This command launches the Chrome Developer Tool web inspector.

6) Shutdown

This command terminates both the Chrome Dev Tool and emulator at the same time.

Now, I can install Node JS Tizen CLI with NPM anywhere on my local machine using Terminal or iTerm. When writing this, the Web debugger continues to only work with Google Chrome 80 and below. Luckily you can find a clean copy on the interwebs.

Can anyone create a Node JS CLI absolutely? Yes, though, your mileage will vary. Below is a list of domain knowledge I needed on hand to put all the pieces together and some new items I had picked up along the way to get me to the finish line:

Tizen CLI instructions
Node JS CLI
JavaScript (Pure ES6)
Shell scripting (Unix/macOS)
Chrome Dev Tools
Terminal (macOS)
File system (map Tizen specific scripts in Node JS)
Google, StackOverflow, Stack Exchange, etc!
TCP, UDP (Networking)
Wireshark

If you enjoyed this short segment, stay tuned for more CLI adventures.

Until next time.