DEV Community: Michael Okoh

Configuring Laravel Queues with AWS SQS

Michael Okoh — Sat, 15 May 2021 09:36:32 +0000

Introduction

Recently, I had to migrate my queue driver on a project from Redis to SQS and for some weird reason the information provided on the official Laravel Queues documentation didn't do justice to this and I couldn't find an article online that could help, that's why I'm writing this, with the hope that you don't spend two hours of your Saturday morning figuring stuff that should have been documented. I'd try to keep this article as brief as possible, I'd attach links to other articles that explain some steps so I can focus on the important parts.

Prerequisites

An existing Laravel application
An AWS account
An understanding of Laravel queues
Some AWS knowledge

Step One - Install the AWS SDK

Run the following command to install the SDK:



composer require aws/aws-sdk-php

Step Two - Get your AWS keys

Click on this link to watch the guide.

When you get to the point where you need to set permissions, search for AmazonSQSFullAccess and select it.

If you already have existing credentials, modify its policies and do the same.

Step Three - Create a queue

Head over to your SQS console, click on create queue.

Out of the box, Laravel dispatches jobs to the default queue, therefore, your first queue should be named default on SQS.

If you would be dispatching to a queue other than default, the queue name should be the same as the queue you're dispatching to.

Leave everything else at its default, scroll to the bottom and click on the create queue button.

Step Four - Set `.env` variables

Open your .env with your preferred text editor. Add your AWS keys in the following format:



AWS_ACCESS_KEY_ID=YOUR_AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION=YOUR_SQS_REGION

Ensure you replace YOUR_* with the right credentials. Next, set your SQS Prefix:



SQS_PREFIX=https://sqs.<your-region>.amazonaws.com/<your-account-id>

| I don't think I need to explain what <your-region> means

You can get <your-account-id> on your AWS console, click on your account name on the top right of your dashboard.

you'd find your account ID just beside My Account as shown above. Finally, change the queue driver to SES.



QUEUE_CONNECTION=sqs

Step Five - Start queue worker

Run the following command to start your queue worker:



php artisan queue:work sqs

Dispatch your job on the default queue and it should be processed.

Modification for Laravel horizon

If you use Laravel Horizon to manage your queues, you'd be making some modifications to your horizon.php file. For each worker defined, change the queue connection from redis which is the default to env('QUEUE_CONNECTION').

From this:



<?php
...
'defaults' => [
    'queue_name' => [
        ...
        'connection' => 'redis',
    ],
...
]
...

To this:



<?php
...
'defaults' => [
    'queue_name' => [
        ...
        'connection' => env('QUEUE_CONNECTION'),
    ],
...
]
...

After these modifications have been made, restart horizon and all should be good.

Conclusion

I have nothing else to add, have fun, keep building.

Understanding Basic Object Oriented Programming with C++

Michael Okoh — Sun, 30 Sep 2018 16:12:10 +0000

Prerequisites

A C++ Compiler installed on your Machine
Basic Understanding of C++
An IDE or Text Editor
Time
Open mind

Introduction

Object-oriented programming is a paradigm in programming that represents real-life objects or entities in code,
For starters, there are two basic but vital concepts you have to understand in OOP namely Classes and Objects.

What is a Class?

A class is a blueprint that specifies the attributes and behavior of an Object. Let's assume we are to create a new class human, we can specify some attributes that are specific to human beings.

...
class human {
  public:
    string name;
    int age;
};
...

In the snippet above we created a class with attributes name and age.

What is an Object?

An Object is an instance of a class, an instance in the sense that it can assume any property or attribute from a class. To make things clear we humans are instances of our genes.

Using the Class we created earlier, we can create an object from it and then assign the attributes name and age a value.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;
};

int main () {
  human exhibitA;

  exhibitA.name = "Michael";
  exhibitA.age = 25;

  cout <<"Exhibit A's Name is "<< exhibitA.name << endl;
  cout <<"Exhibit A's Age is "<< exhibitA.age << endl;

  return 0;
}

In the snippet above we have successfully created a Class and we have also created an object and assigned that object attributes from the parent class.

At this point, you should have an understanding of how classes and objects. Note that a class is not limited to just one object, you can create as much object as you want.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;
};

int main () {
  human exhibitA;
  human exhibitB;

  exhibitA.name = "Michael";
  exhibitA.age = 25;

  exhibitB.name = "Nerfetiti";
  exhibitB.age = 24;

  cout <<"Exhibit A's Name is "<< exhibitA.name << endl;
  cout <<"Exhibit A's Age is "<< exhibitA.age << endl;

  cout <<"Exhibit B's Name is "<< exhibitB.name << endl;
  cout <<"Exhibit B's Age is "<< exhibitB.age << endl;

  return 0;
}

As seen in the Snippet above, a new object was created and was assigned attributes as defined in the parent class.

What are Behaviours?

Another concept we would be looking into is behaviors, behaviors are actions that an object can perform. For example, a human can run, eat, sleep and so on.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;

    void run () {
      cout << name <<" is running" << endl;
    }
};

int main () {
  human exhibitA;

  exhibitA.name = "Michael";  
  exhibitA.run();

  return 0;
}

As seen in the snippet above, a function was created to pass the public name variable to print "Michael is running". Based on the object assigned to that function/ behavior it would pass the parameters required by that function/ behavior via the dot notation.

What is Overloading?

Overloading is a concept that allows you to use the same function name to perform different operations based on the parameters passed to it. For this example, we would be creating a new behavior eat(), with no parameter, with one parameter and two parameters.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;

    void eat () {
      cout << name <<" is eating" << endl;
    }
};

int main () {
  human exhibitA;

  exhibitA.name = "Michael";
  exhibitA.eat();

  return 0;
}

As seen above, we created a behavior named eat with no parameter, which should return "Michael is eating" or whatever name you declare as exhibitA name.

Moving on we would overload the eat behavior by requiring a parameter for another behavior also named eat.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;

    void eat () {
      cout << name <<" is eating" << endl;
    }

    void eat (string food1) {
      cout << name <<" is eating "<< food1 << endl;
    }
};

int main () {
  human exhibitA;

  exhibitA.name = "Michael";
  exhibitA.eat();
  exhibitA.eat("Rice");

  return 0;
}

The snippet above has a second eat function but requires a parameter, this parameter was passed to form "Michael is eating Rice" based on the object assigned to it.

Now finally let us create a new eat behavior that accepts two parameters.

#include <iostream>
using namespace std;

class human {
  public:
    string name;
    int age;

    void eat () {
      cout << name <<" is eating" << endl;
    }

    void eat (string food1) {
      cout << name <<" is eating "<< food1 << endl;
    }

    void eat (string food1, string food2) {
      cout << name <<" is eating "<< food1 << " and " << food2 << endl;
    }
};

int main () {
  human exhibitA;

  exhibitA.name = "Michael";
  exhibitA.eat();
  exhibitA.eat("Rice");
  exhibitA.eat("Rice", "Beans");

  return 0;
}

The final output for this snippet is "Michael is eating Rice and Beans", the last eat call triggers the overloaded eat behavior with two parameters declared in the human class because we passed exactly two arguments.

If you Notice all other eat behaviors declared still works regardless of other eat behaviors declared after or before.

Conclusion

By now you should have an Idea of how object-oriented programming works but not just in C++, this concept is applicable to other programming languages but in a different syntax. I missed some concept like Inheritance, Polymorphism, Data abstraction and Interfaces. I would try to cover these concepts in another article, Have fun.

Basic Routing, HTTP Requests, and CRUD Operation with Express and MongoDB

Michael Okoh — Wed, 31 Jan 2018 17:54:59 +0000

First Published in JavaScript January

Hello there,

Let's talk about routes. A route is simply an entry point into your application. So we are going to build routes to perform some HTTP requests with ExpressJS.

Getting Started

First, we'll need to do some setup:

create a new folder and name it whatever you want: mkdir express-routes
change your terminal directory to that folder: cd express routes
run npm init (you can press enter for all prompts).
install Express: npm install express --save
create a new file in that folder: touch index.js
Now open index.js in your favorite text editor, in my case Atom

Then we need to import Express into our application:

const express = require('express');
const app = express();

Now we have to create a server where browsers and API calls can connect. We can do that with Express' listen method:

app.listen(3000, function() {
  console.log('listening on 3000');
});

You can test your server by running node index.js. You should see this:

Adding our First Routes

Now let's create a route that we can access in the browser. Browsers only serve pages using a GET request, so we need to create a route using Express' get method like this:

app.get('/', function(req, res) {
  res.send("Yep it's working");
});

You'll need to restart your Node server to see this update. You can do this by typing CTRL + C to stop your server and then run node index.js. If you visit http://localhost:3000 on your web browser, you should see this:

Let's add another route:

app.get('/love', (req, res) => {
  res.send('Hi Love');
});

If you visit http://localhost:3000/love, you should see this:

You may have noticed I'm now using an arrow function, which is an ES6 feature. You can learn more about the ES6 specification here.

Now that we've learned how to create a basic route in Express, let's go further by learning CRUD operations using MongoDB. But before we move forward, aren't you tired of restarting your server every time you make a change? You can fix this problem by using a package called Nodemon.

Adding Nodemon

You can install Nodemon by running npm install nodemon --save-dev. Then edit your package.json like this:

Now run npm run dev in your terminal, and you should see:

Now with Nodemon set up, you won't have to restart your server whenever you make a change. However, you will need to refresh your browser to see those changes.

CRUD Operations

CRUD (create, read, update, and delete) operations are the four basic database functions. For this tutorial, we'll use a remote MongoDB service called mLab. We'll be building a simple application to store and retrieve first_name and last_name values from our database.

Setting up MongoDB and mLab

To create a new account and set up a database, you will need to go here. I've provided the images below as a reference guide on setting up your database.

create a new MongoDB Depoyment

select Amazon which is the free teir provider

select a region where you want your database to be hosted, select a region close to where you live for better performance

specify a name for your database, in my case i named mine crud

confirm your specifications/order

go to the Users tab to create a new Database user

when done. the user created should pop up

mLab should give you your credentials, which can be found at the top

replace <dbuser> and <dbpassword> with the credentials of the user you just created

With our remmote database set up, we can install MongoDB in our application by running:

npm install mongodb --save

Now let's import MongoDB into our application:

const MongoClient = require('mongodb').MongoClient
var ObjectID = require('mongodb').ObjectID; // we will use this later

MongoClient.connect('link-to-mongodb', (err, database) => {
  // ... start the server
})

Remember to replace link-to-mongodb with the URL mLab gave you, in my case:

mongodb://<dbuser>:<dbpassword>@ds247027.mlab.com:47027/crud

Also be sure to replace <dbuser> and <dbpassword> with the credentials you created.

Now wrap the listen method within the MongoClient callback like this:

MongoClient.connect('mongodb://trojan:00000000@ds247027.mlab.com:47027/crud', (err, db) => {
  var dbase = db.db("crud");
  if (err) return console.log(err)
  app.listen(3000, () => {
    console.log('app working on 3000')
  })
})

Keep these in mind

HTTP Verb     Operation
GET           Read
POST          Create
PUT           Update
DELETE        Delete

Earlier we learned that a browser gets pages via the GET request, but to add data to a database we will need to use the POST request. We can use a service called postman to send these requests.

For our application to receive post requests, we will need a package called body-parser, which we can install by running npm install body-parser --save. Then we can import it into our application like this:

const express = require('express');
const MongoClient = require('mongodb').MongoClient
var ObjectID = require('mongodb').ObjectID;
const bodyParser= require('body-parser')
const app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));

Creating an Entry

We'll use the POST HTTP verb to create a new entry in our database. Let's create our post route:

app.post('/name/add', (req, res, next) => {

    var name = {
      first_name: req.body.first_name,
      last_name: req.body.last_name
    };

    dbase.collection("name").save(name, (err, result) => {
      if(err) {
        console.log(err);
      }

      res.send('name added successfully');
    });
  });

To test this application:

open Postman
tick x-www-form-urlencoded
make a post request to http://localhost:3000/name/add with the key as first_name and last_name like this:

If you see name added successfully, you can check your mLab Dashboard and find a new collection called name.

And if you click on name, you will see the data you sent in your post request:

Reading All Entries

Now let's add a function to handle GET requests to our database in Express.

app.get('/name', (req, res) => {
    dbase.collection('name').find().toArray( (err, results) => {
      res.send(results)
    });
});

We can test with Postman by sending a GET request to http://localhost:300/name like this:

Reading by ID

We can also make GET requests by id which is automatically assigned to entries in our database. We can add that id to our request via the URL.

For example, the data we have in the image above has the id of 5a5252b2d60a9f4a4254bade. So when we pass its id in the URL like this:

it would return the entry associated with that id. We can add an Express handler for this type of request like this:

app.get('/name/:id', (req, res, next) => {
    if(err) {
      throw err;
    }

    let id = ObjectID(req.params.id);
    dbase.collection('name').find(id).toArray( (err, result) => {
      if(err) {
        throw err;
      }

      res.send(result);
    });
 });

Updating by ID

We learned how to add data using a POST request and how to retrieve data using a GET request. Now we are going to add a handler to update an existing record by id using a PUT request:

app.put('/name/update/:id', (req, res, next) => {
    let id = {
      _id: ObjectID(req.params.id)
    };

    dbase.collection("name").update({_id: id}, {$set:{'first_name': req.body.first_name, 'last_name': req.body.last_name}}, (err, result) => {
      if(err) {
        throw err;
      }
      res.send('user updated sucessfully');
    });
});

We can test this using Postman. I added more data, as you can see in the image below:

[
    {
        "_id": "5a52a2a314622d0c85d8da3f",
        "first_name": "Thomas",
        "last_name": "Okoh"
    },
    {
        "_id": "5a52b1dc8635184cf9f7fd32",
        "first_name": "Kun",
        "last_name": "Aguero"
    },
    {
        "_id": "5a52b1e48635184cf9f7fd33",
        "first_name": "Ed",
        "last_name": "Sheeran"
    },
    {
        "_id": "5a52b1ee8635184cf9f7fd34",
        "first_name": "Christiano",
        "last_name": "Ronaldo"
    },
    {
        "_id": "5a52b2008635184cf9f7fd35",
        "first_name": "Adekunle",
        "last_name": "Gold"
    }
]

Let's try to edit this entry:

{
    "_id": "5a52b1ee8635184cf9f7fd34",
    "first_name": "Christiano",
    "last_name": "Ronaldo"
}

We'll use a PUT method in Postman to update last_name from Ronaldo to Messi and first_name from Christiano to Lionel using the id: 5a52b1ee8635184cf9f7fd34.

When we check the entries in our database, we see they have been updated.

[
    {
        "_id": "5a52a2a314622d0c85d8da3f",
        "first_name": "Thomas",
        "last_name": "Okoh"
    },
    {
        "_id": "5a52b1dc8635184cf9f7fd32",
        "first_name": "Kun",
        "last_name": "Aguero"
    },
    {
        "_id": "5a52b1e48635184cf9f7fd33",
        "first_name": "Ed",
        "last_name": "Sheeran"
    },
    {
        "_id": "5a52b1ee8635184cf9f7fd34",
        "first_name": "Messi",
        "last_name": "Lionel"
    },
    {
        "_id": "5a52b2008635184cf9f7fd35",
        "first_name": "Adekunle",
        "last_name": "Gold"
    }
]

Deleting by ID

Finally, we've arrived at the last phase of this application: deleting entries by id. We will do this by using the DELETE request. Let's create a handler function in our application.

app.delete('/name/delete/:id', (req, res, next) => {
    let id = ObjectID(req.params.id);

    dbase.collection('name').deleteOne(id, (err, result) => {
      if(err) {
        throw err;
      }

      res.send('user deleted');
    });
 });

Let's review our current entries:

 [
    {
        "_id": "5a52a2a314622d0c85d8da3f",
        "first_name": "Thomas",
        "last_name": "Okoh"
    },
    {
        "_id": "5a52b1dc8635184cf9f7fd32",
        "first_name": "Kun",
        "last_name": "Aguero"
    },
    {
        "_id": "5a52b1e48635184cf9f7fd33",
        "first_name": "Ed",
        "last_name": "Sheeran"
    },
    {
        "_id": "5a52b1ee8635184cf9f7fd34",
        "first_name": "Messi",
        "last_name": "Lionel"
    },
    {
        "_id": "5a52b2008635184cf9f7fd35",
        "first_name": "Adekunle",
        "last_name": "Gold"
    }
]

We'll delete this one:

{
    "_id": "5a52b2008635184cf9f7fd35",
    "first_name": "Adekunle",
    "last_name": "Gold"
}

We'll make our DELETE request via Postman:

Success!!!

[
    {
        "_id": "5a52a2a314622d0c85d8da3f",
        "first_name": "Thomas",
        "last_name": "Okoh"
    },
    {
        "_id": "5a52b1dc8635184cf9f7fd32",
        "first_name": "Kun",
        "last_name": "Aguero"
    },
    {
        "_id": "5a52b1e48635184cf9f7fd33",
        "first_name": "Ed",
        "last_name": "Sheeran"
    },
    {
        "_id": "5a52b1ee8635184cf9f7fd34",
        "first_name": "Messi",
        "last_name": "Lionel"
    }
]

Our entry has been deleted.

Conclusion

At this point, your index.js should look like this:

const express = require('express');
const MongoClient = require('mongodb').MongoClient
const bodyParser= require('body-parser')
var ObjectID = require('mongodb').ObjectID;
const app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));

MongoClient.connect('mongodb://trojan:00000000@ds247027.mlab.com:47027/crud', (err, db) => {
  if (err) return console.log(err)

  app.listen(3000, () => {
    console.log('app working on 3000')
  });

  let dbase = db.db("crud");

  app.post('/name/add', (req, res, next) => {

    let name = {
      first_name: req.body.first_name,
      last_name: req.body.last_name
    };

    dbase.collection("name").save(name, (err, result) => {
      if(err) {
        console.log(err);
      }

      res.send('name added successfully');
    });

  });

  app.get('/name', (req, res, next) => {
    dbase.collection('name').find().toArray( (err, results) => {
      res.send(results)
    });
  });

  app.get('/name/:id', (req, res, next) => {
    if(err) {
      throw err;
    }

    let id = ObjectID(req.params.id);
    dbase.collection('name').find(id).toArray( (err, result) => {
      if(err) {
        throw err;
      }

      res.send(result);
    });
  });

  app.put('/name/update/:id', (req, res, next) => {
    var id = {
      _id: new ObjectID(req.params.id)
    };

    dbase.collection("name").update(id, {$set:{first_name: req.body.first_name, last_name: req.body.last_name}}, (err, result) => {
      if(err) {
        throw err;
      }

      res.send('user updated sucessfully');
    });
  });


  app.delete('/name/delete/:id', (req, res, next) => {
    let id = ObjectID(req.params.id);

    dbase.collection('name').deleteOne({_id: id}, (err, result) => {
      if(err) {
        throw err;
      }

      res.send('user deleted');
    });
  });

});

All done. If you followed this article to this point, you should be very proud of yourself. Go forth and build for the next billion users.

You can always reach out to me on Twitter

Bye

DEV Community: Michael Okoh

Configuring Laravel Queues with AWS SQS

Introduction

Prerequisites

Step One - Install the AWS SDK

Step Two - Get your AWS keys

Step Three - Create a queue

Step Four - Set .env variables

Step Five - Start queue worker

Modification for Laravel horizon

Conclusion

Understanding Basic Object Oriented Programming with C++

Prerequisites

Introduction

What is a Class?

What is an Object?

What are Behaviours?

What is Overloading?

Conclusion

Basic Routing, HTTP Requests, and CRUD Operation with Express and MongoDB

Getting Started

Adding our First Routes

Adding Nodemon

CRUD Operations

Setting up MongoDB and mLab

Creating an Entry

Reading All Entries

Reading by ID

Updating by ID

Deleting by ID

Conclusion

Step Four - Set `.env` variables