Forem: Edgar Gonzalez

Free Exchange rate API

Edgar Gonzalez — Sat, 09 May 2020 20:24:16 +0000

Hey guys, right now I'm looking for an API that allows you to convert from one currency to another, this is for a personal project so I'm looking for something free at the moment, I found several APIs that offer a free version but they all limit the number of requests per month, and is usually a very small amount.

Any help would be very appreciated.

How to deploy your app on AWS with Docker

Edgar Gonzalez — Sun, 03 May 2020 05:17:49 +0000

I will be explaining how to deploy your dockerized app in AWS using a Fargate instance, the process for an EC2 instance should be very similar, so this guide will also work for you.

In a previous article, I explained how to dockerize a NestJs app, for the purpose of this guide I will be using the same codebase to create the Docker image that will be deployed in AWS.

To follow these steps I will assume you have the following:

A Docker script to build your image.
The AWS cli configured in your machine.
Some basic knowledge of AWS and Docker.

Step 1 - Docker repository

You need to create a Docker repository in your AWS account, it can be done executing the command below:

aws ecr create-repository --repository-name=<YOUR_REPOSITORY_NAME>

After your repository is created go to Elastic Container Service -> Amazon ECR -> Repositories in your AWS account. There look for your newly created repository and click on it. Once your repo is opened click on the View push commands button. You will get something like this:

Copy all these commands, as you will need them later on to build, push and deploy your app.

To avoid copying these commands every time we build our app, we can create some scripts in our package.json to automate the process.

If you are not deploying a JS app, you can use a shell script or some other tool you feel comfortable with.

Step 2 - Automated script

To make our lives easier we will setup the following scripts in the package.json file:

...
"aws:login": "aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin <ID>.dkr.ecr.us-west-2.amazonaws.com/nestjs",
"docker:build": "docker build -t nestjs .",
"docker:tag": "docker tag nestjs:latest <ID>.dkr.ecr.us-west-2.amazonaws.com/nestjs:latest",
"docker:push": "docker push <ID>.dkr.ecr.us-west-2.amazonaws.com/nestjs:latest",
...

Remember to replace all these commands with the ones you copied from your repository.

Let me explain what each one of these commands do:

aws:login - Executed the login command so you can properly authenticate with your AWS cli.
docker:build - Build your Docker image using your local Docker script.
docker:tag - Tag your recently created image with the name you copied from your repository.
docker:push - Push your image to the AWS server.

I will also add a new script, to execute all the previous commands in secuence (yes, I'm a bit lazy, I don't want to type all those commands every time I build my image).

...
"aws:build": "npm run aws:login && npm run docker:build && npm run docker:tag && npm run docker:push",
...

Now if you run the aws:build command (npm run aws:build), you will build, tag and push your Docker image into your AWS account. We will use this on the next steps to deploy your app. After executing the command this is how my repository looks:

Step 3 - Create Task Definition

Before creating your task definition make sure you have a role with the AmazonECSTaskExecutionRolePolicy.

Now, you need to create a Task definition that will be later used by a service to create the instances of your Docker image. To create a Task definition go to Elastic Container Service -> Amazon ECS -> Task Definitions, and click on the Create new Task Definition button and follow the next steps:

Select launch type compatibility - Fargate.

Set your task name and execution role.

Set task size (this will change depending on your needs).

Create task container (for the purpose of the guide I won't go deep on each of the options you can specify here, I will keep it simple for now).

For the Image field you need to specify the URL of your repository.

Save your task.

Step 4 - Create Cluster

On this step you will create the cluster that will be used to create the services to deploy your app.

Select Networking Only cluster as we will be creating Fargate instances.

Set cluster name, check the "Create VPC" checkbox and save.

Step 5 - Create Service

Go to the services tab inside your recently created cluster and click on the Create button.

Set your service type as Fargate, your task definition and cluster as the ones you created, for the service name I usually have the -service suffix to identify them easier. And for this case we will set the number of instances as 1 (this will depend on your needs).

Set the VPC value with the one that was created with the cluster and set some subnets where your service will be available, also set the "Auto-assign public IP" property to "Enabled". For the rest of the fields you can keep them as their default values and click the Next step button.

For the Auto-scaling options, keep the default values and click the Next step button.
Click Create Service and wait for your service to be created.

Now that you have created your service, let's check our deployed app. First you need to go to the task that was created by your service.

Here you can find the Public IP address of your instance. And looking for that IP directly on your browser should show your running APP.

Running APP

NOTE: if your app is not running on the port 80 you will need to open the port your container is exposing on the security group that your service is using, this can be done on your security group inbound rules.

Awesome!! You made it!! now your app is running on a Fargate container in AWS, but, what if we need to make some changes in our app? How do we update our Docker image and re-deploy the new changes?. I will talk about it in the next step.

Step 6 - Re-Deploy your app with new changes.

Imagine that we got a new requirement for a new feature on our app, and we need to push those changes to our Fargate container, for that there are a couple of steps we need to follow:

Build Docker image with new changes.
Tag Docker image.
Push Docker image.
Deploy container with the new changes.

The first 3 steps we got them covered on the scripts we created before, we only need one last script.

"aws:deploy": "aws ecs update-service --cluster test-cluster --service nestjs-service --force-new-deployment --region=<YOUR_REGION>",

This command will force your service to re-create with the latest changes from the Docker image. After making new changes on your app you can run the following command:

npm run aws:build && npm run aws:deploy

This command will build, tag, push and re-create the container with the latest changes.

You can find the source code for this guide here.

How to easily Dockerize your NestJs App

Edgar Gonzalez — Sat, 02 May 2020 19:22:18 +0000

In this previous article I talked about how to create cron jobs with a NestJs application, now I'm going to take that same app and create a Docker script that we can use to deploy it on a production environment like AWS.

You can find the source code for this guide here.

I will assume you have some basic knowledge of how Docker works for this guide.

To Dockerize our app we are going to be using the following Docker file:

You can also find a gist for this Docker script here.

FROM node:12.15.0-alpine

# Create app directory
WORKDIR /usr/src/app

# Copy package files
COPY package*.json ./

# Install npm packages
RUN npm install

# Bundle app source
COPY . .

# Build our app for production
RUN npm run build

EXPOSE 3000
CMD [ "npm", "run", "start:prod" ]

I will go through each of the lines on the file and explain what they mean.

FROM node:12.15.0-alpine

In this line we are telling Docker to use as a base image the node:12.15.0-alpine, this node version was enough for the purpose of our app, I recommend always using a fixed version for your Docker scripts and not the latest o stable one, because when those versions change something can break on your app. So manual version updated are preferred by me.

WORKDIR /usr/src/app

This is the directory where we will copy and build our app.

COPY package*.json ./

A wildcard is used to ensure both package.json AND package-lock.json are copied where available (npm@5+)

RUN npm install

Here we will install all npm dependencies. It is recommended to use npm ci instead for prod environment, but I had some trouble to make that work properly with NestJs build command so I kept it simple with the usual npm install

COPY . .

Copy the rest of the app files. To avoid copying unwanted files, like the local dist folder or node_modules folder use a .gitignore file.

RUN npm run build

Execute the build command of our project, this will internally execute the NestJs build command and will generate the distribution files of our app.

EXPOSE 3000

This line is to expose port 3000 on the Docker instance that will be created. This port will depend on the port your app runs.

CMD [ "npm", "run", "start:prod" ]

Finally, execute our app and keep it running in the Docker instance.

To test the Docker script you can execute the following commands on the root of the project, remember to create the Docker and the .dockerignore files.

Build docker image docker build -t nestjs-cron .
Run docker instance on port 3010 of our local machine docker run --name nestjs-cron -p 3010:3000 nestjs-cron

As you saw it is very simple to dockerize our NestJs app. See you the next time.

How to schedule a cron job with NestJs in less than 5 mins

Edgar Gonzalez — Sat, 02 May 2020 19:20:33 +0000

Yes, I know you can setup a cron job directly with Linux, or with plain node libraries, but, in my case coming from and angular background developing with NestJs made things much simpler, also, I think it is really fun trying new approaches just for the sake of it. Taking that into account let's continue.

Creating cron this way is not at OS level, it will only be at app level, so if your app stops the cron won't execute anymore.

This is particularly useful when you don't have access to change or set OS level configurations.

A couple of days ago I was in the need of developing a very simple app, that fetched some information from an API every minute and posted the results in a Slack channel (you can read about the slack part over here). I have developed a couple of apps with NestJs in the past and wanted to give it a try this time.

The first thing you need to do is to install NestJs cli (if you haven't already), with the following command:

npm i -g @nestjs/cli

You can also use npx if you don't want to install the cli globally.

After that you can create your project with this command:

nest new project-name

There is already a built-in Scheduler module inside NestJs we can use, and it uses node-cron package internally, you can install it with the following command:

npm install --save @nestjs/schedule

Once you have installed the package add it to the app.module like this:

import { Module } from '@nestjs/common';
import { ScheduleModule } from '@nestjs/schedule';

@Module({
  imports: [
    ScheduleModule.forRoot()
  ],
  ...
})
export class AppModule {}

Now, you need to create a service and provide it in your app.module as well, that will be as simple as running the following command:

nest generate service cron

Now that you have the service ready let me explain some types of crons you can create with the Schedule module.

Custom cron expressions, something similar to 10 * * * *, that will run your cron every 10 minutes or 0 20 * * *, that will run your cron every day at 8:00 PM. You can read more about cron expressions here.
Predefined expressions from the CronExpression enum, something like CronExpression.EVERY_MINUTE or CronExpression.EVERY_2_HOURS, this enum contains common human-readable cron expressions you can use.
Crons that runs only once after X milliseconds, something like run 5 minutes after the app started.

Custom cron expressions

To set custom cron expressions, you need to use the @Cron decorator over the method that will be executed:

@Cron('*/10 * * * * *')
runEvery10Seconds() {
 console.log('Every 10 seconds');
}

Predefined cron expressions

To use predefined expressions you also need to use the @Cron decorator, but instead of writing the expression yourself you will take it from the CronExpresion enum:

@Cron(CronExpression.EVERY_MINUTE)
runEveryMinute() {
 console.log('Every minute');
}

You can find all Predefined expressions here.

Run once after x milliseconds

If you ever come to a scenario that you need to execute a method some time after your app started, and only once, you can use the @Timeout decorator like this:

@Timeout(15000)
onceAfter15Seconds() {
 console.log('Called once after 15 seconds');
}

Once you run npm run start:dev, you will see something similar to this in your terminal:

Every 10 seconds
Called once after 15 seconds
Every 10 seconds
Every 10 seconds
Every 10 seconds
Every 10 seconds
Every minute
Every 10 seconds

Those are all the types I will cover on this post, there are other cool functionalities for creating cron jobs dynamically using Schedule modules API. You can take a deeper look here.

You can find the source code for this example here. See you the next time.

And if you are interested on how to dockerize your NestJs app, you can check this article.

How to create a Slack robot in 3 easy steps

Edgar Gonzalez — Sat, 02 May 2020 16:04:28 +0000

Hey guys a few days ago I needed to create a Slack app to fetch details from one API and post into a Slack channel if there were any changes. I'm going to explain an easy step by step on how to create your own Slack app and post custom messages on a channel.

Step 1 - Get your APP token

The first thing you need is to do is creating a Slack app. You can do that going here. Once you have your app ready, you need to give it the correct permissions to post messages in a channel (for the purpose of this guide, I'm going to assume you only need to post messages to a particular channel, and you also know the channel ID as this was also my case).

Requesting these permissions is as easy as:

Load up the settings for your app from the app management page.
In the navigation menu, choose the OAuth & Permissions feature.
Scroll down to the Scopes section, and pick chat:write from the drop-down menu.
Scroll back to the top of this page and look for the button that says 5. Install App to Workspace (or Reinstall App if you've done this before). Click it.

You'll now see a permission request screen to install your app to its original workspace.

If you had already installed your app to its original workspace before, you might still see the permissions screen if the scopes you just added weren't previously granted to your app.

Authorize your app and you should see a success message. On the OAuth & Permissions settings page you're brought back to, you should now see an OAuth access token available.

Grab this token and store it for later, as we'll use that token to make some Web API calls.

If you want to read more about all the scopes you can add to your app and the details, you can click here.

Step 2 - Add your app in the channel

One important step also, is to add your recently created app to your channel, go to your channel details and click on "Add apps"

Find your app and click on the "Add" button

Step 3 - Post messages in a Slack channel

Copy your app access token:

Find the channel ID you will be posting the messages into, you can find it here:

After you have completed previous steps, is only a matter of making a post request to this API:

POST https://slack.com/api/chat.postMessage
Content-type: application/json
Authorization: Bearer YOUR_TOKEN_HERE
{
  "channel": "YOUR_CHANNEL_ID",
  "text": "Hello, world"
}

In my case it was something like this:

POST https://slack.com/api/chat.postMessage
Content-type: application/json
Authorization: Bearer <my-app-token>
{
  "channel": "test-channel",
  "text": "Hello, world"
}

You will get something similar to the image below on your channel:

And that will be all guys, if you want to make more complex messaging interactions I recommend you going to the Slack documentation and read more about it.

See you next time.