DEV Community: ByteBricks.ai

Unleashing Laravel Queues with AWS SQS: A Step Towards Outsourced Processing

ByteBricks.ai — Wed, 11 Oct 2023 18:59:34 +0000

In the ever-evolving landscape of web development, the ability to offload and manage tasks asynchronously is no longer a luxury, but a necessity. Especially when dealing with resource-hungry 🤑operations that could potentially bring your application to a crawl.

This is where Laravel’s queue management shines, and coupling it with Amazon Simple Queue Service (AWS SQS) is like giving it a jetpack to soar into the clouds. This duo allows you to dispatch jobs to be handled by external workers, thereby outsourcing resources and ensuring your application runs smoothly, no matter the load.

Setting The Stage

Before we dive into the mechanics, ensure you have the AWS SDK for PHP installed via Composer:

composer require aws/aws-sdk-php

Configuring Laravel

In your Laravel project, navigate to config/queue.php and configure the sqs connection:

'sqs' => [
    'driver' => 'sqs',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'prefix' => env('AWS_SQS_PREFIX', 'https://sqs.us-east-1.amazonaws.com/your-account-id'),
    'queue' => env('AWS_SQS_QUEUE', 'your-queue-name'),
    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
],

In your .env file, make sure to fill in the necessary AWS credentials and queue information:

AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_SQS_PREFIX=https://sqs.us-east-1.amazonaws.com/your-account-id
AWS_SQS_QUEUE=your-queue-name
AWS_DEFAULT_REGION=us-east-1

Prepping Your Jobs

Creating a job in Laravel is a breeze. Use the *Artisan * 😍command to generate a new job class:

php artisan make:job ProcessTask

This will create a ProcessTask class within the App\Jobs namespace. Here’s a _simplified _ example of what your job might look like:

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProcessTask implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $data;

    public function __construct($data)
    {
        $this->data = $data;
    }

    public function handle()
    {
        // Process your data...
    }
}

Dispatching Jobs to AWS SQS

Dispatching a job to the SQS queue is as simple as calling the dispatch method on your job class:

ProcessTask::dispatch($data);

Your job is now on a swift journey to AWS SQS 🎉, awaiting an external worker to pick it up 😋.

External Workers: The Unsung Heroes 👑

Having your jobs dispatched is half the battle. Now comes the part where external workers step in to process these jobs. You could set up a dedicated server or utilize a service that specializes in processing queue jobs.

On your worker server, ensure you have a clone of your Laravel project. Then, run the queue worker to start processing jobs:

php artisan queue:work sqs

Scaling the Horizon

By now, you have a well-oiled machine ready to handle a barrage of tasks without breaking a sweat. This setup shines in scenarios where resource-intensive tasks can be outsourced to external workers, allowing your main application to serve user requests swiftly.

Moreover, this model is scalable. As the load increases, spawn more workers to chew through the job queue😄. It’s all about keeping the gears turning smoothly while your application continues to cater to your users without a hiccup.

A Bite of Real-world Scenario

Imagine a case where your application needs to scrape vast amounts of data from various sources. The web scraping tasks are perfect candidates for outsourcing. Dispatch these tasks to AWS SQS, let the external workers do the heavy lifting, and have the results shipped back to your application for further use.

With a friendly handshake between Laravel and AWS SQS, the sky's the limit in managing asynchronous tasks efficiently. This setup not only paves the way for better resource management but also sets a robust foundation for scaling your application as it grows. It’s about making your application a well-coordinated orchestra, delivering a seamless symphony of operations, with each musician, the external worker in this case, playing its part to perfection.

I hate Typescript, is it a shame?

ByteBricks.ai — Wed, 04 Oct 2023 20:28:21 +0000

But am I alone in this boat, gently rowing down the river of resistance against the *TypeScript * tide? Or are there others who share this sentiment 😍? Or better yet, are there knights in shining armor ready to defend TypeScript’s honor and educate the peasants like me on the path of righteous coding 🤣🤣?

I love Javascript but Hate Typescript!

Here are some discussion nuggets to chew on:

Why is TypeScript hailed as the savior of big projects? Is it really the unsung hero in the sprawling chaos of JavaScript?
For the TypeScript fans, share your “Aha!” moment when TypeScript clicked for you 😎.
And for my fellow “TypeScript skeptics”, why do you really hate it?

Explain API Like I'm Five

ByteBricks.ai — Tue, 03 Oct 2023 23:06:05 +0000

We build and sell Data APIs, I want the help of this great community on explaining API service to non developers, business people, and users. How will you explain it?

Laravel: Tailwind Livewire UI Components

ByteBricks.ai — Tue, 03 Oct 2023 22:37:14 +0000

Oh, the sweet allure of Tailwind CSS! It’s like that trendy cafe downtown everyone wants a piece of. The sleek, utility-first structure it brings to the table has made it a darling in the web development realm. Now, pair that up with Laravel Livewire, and you’ve got yourself a match made in heaven, or should I say, in code. But what if we could spice this love affair up a notch? Enter WireUI components at Livewire-WireUI.com. This nifty toolkit is like the secret sauce to injecting Tailwind CSS goodness into Livewire, making Laravel development faster, more enjoyable, and oh-so beautiful 😍.

Cutting to the Chase with WireUI

We’ve all been there - wanting to whip up a user interface that’s not only easy on the eyes but also a breeze to work with. That's where WireUI comes in, offering a smorgasbord of pre-built UI components 🔥 ready to be embraced by your Livewire projects. It’s like finding a shortcut on your morning commute that shaves off precious minutes, allowing you to catch extra zzz’s or, let’s be honest, another episode of your favorite series😎.

Tailwind CSS Meets Livewire: A Symphony of Productivity

The harmony between Tailwind CSS and Livewire is something akin to a well-orchestrated symphony. Tailwind CSS lays down the rhythm with its intuitive utility classes, making styling feel like a walk in the park. On the other hand, Livewire conducts the melody, orchestrating state-driven components seamlessly without breaking a sweat😁.

Look at these nice components

Simple Input

Email input with suffix

Searchable Select Dropdown!

Color Picker

Diving Deeper: A Look Under the Hood

To install simply

composer require wireui/wireui

Add the WireUI tag above Alpinejs script tag in your page layout:

<html>
    <head>
        ...
        <wireui:scripts />
        <script src="//unpkg.com/alpinejs" defer></script>
    </head>
</html>

Alternatively, you can use the equivalent Blade directive:

...
@wireUiScripts
<script src="//unpkg.com/alpinejs" defer></script>
...

Sometimes you need to pass extra html attributes to script tag, like the nonce attribute
@wireUiScripts(['nonce': 'csp-token'])
@wireUiScripts(['nonce': 'csp-token', 'foo' => true])

Add the following settings to your Tailwindcss config file, tailwind.config.js:

module.exports = {
    ...
    presets: [
        ...
        require('./vendor/wireui/wireui/tailwind.config.js')
    ],
    content: [
        ...
        './vendor/wireui/wireui/resources/**/*.blade.php',
        './vendor/wireui/wireui/ts/**/*.ts',
        './vendor/wireui/wireui/src/View/**/*.php'
    ],
    ...
}

WireUI does not need any additional configuration, but you can publish the files and customize them to your preference.

php artisan vendor:publish --tag='wireui.config'
php artisan vendor:publish --tag='wireui.resources'
php artisan vendor:publish --tag='wireui.lang'

Beyond the Horizon: Exploring the Ecosystem

The beauty of the Laravel ecosystem is its boundless capacity for growth and innovation. Take ByteBricks for instance. This platform takes Laravel development up a notch, offering solutions that dovetail perfectly with the principles of rapid, elegant coding we see in WireUI.

Remember our little rendezvous with Laravel’s whereHas magic? Or that time we embarked on a data-scraping quest with GPT-3 and Cheerio? Well, WireUI fits right into this narrative of efficiency and elegance. It’s about having the right tools at your disposal to transform ideas into reality, without getting entangled in the nitty-gritty. With the Laravel ecosystem continually evolving, who knows what exciting concoctions we’ll stir up next?

Cheerio & ChatGPT: A Primer on Web Scraping with Node.js

ByteBricks.ai — Sat, 30 Sep 2023 21:27:04 +0000

Hey there fellow data digger (we dig at bytebricks.ai)! The web is a treasure trove of information waiting to be unearthed. And guess what? With a sprinkle of Cheerio and a dash of Node.js, you can turn your code into a data-gathering wizard.

But, hey, let's add a fun twist to it! Ever heard of ChatGPT? 😂 This buddy can take a peek at HTML and whip up the Cheerio code you need to grab that data. Let’s dive into this delicious bowl of Cheerio (pun totally intended) and see how we can make web scraping a breeze.

Prepping Up

Before we start, make sure Node.js is comfortably nestled in your machine. Create a cozy little space for your project, hop into that directory via the terminal, and kickstart a new Node.js project with a simple:

npm init -y

Next up, let’s invite Cheerio and Axios (our trusty HTTP client) to the party with:

npm install cheerio axios

Snagging that HTML

Alright, with the gang all set, let’s nab the HTML of the website we’re eyeing. For this little adventure, we’re gonna pretend we’re extracting goodies from a make-believe e-commerce site.

const axios = require('axios');

async function fetchHTML(url) {
  const { data } = await axios.get(url);
  return data;
}

const url = 'https://fictional-ecommerce-site.com';
fetchHTML(url).then(console.log);

Let Cheerio Lead the Way

Got the HTML? Sweet! Now, let’s hand it over to Cheerio for some parsing action.

const cheerio = require('cheerio');

async function parseHTML(html) {
  const $ = cheerio.load(html);

  // Let’s pretend each product is nestled
  $('.product').each((i, element) => {
    const title = $(element).find('.product-title').text();
    const price = $(element).find('.product-price').text();

    console.log(`${title}: ${price}`);
  });
}

fetchHTML(url).then(html => parseHTML(html));

See what we did there? It’s like we’re using jQuery!, but with the turbo engines of Node.js.

ChatGPT comes handy

Now for the cherry on top! ChatGPT can take a look at HTML and conjure up the Cheerio code you need to snatch that data. Just feed it the HTML, and voila, you’ve got your data extraction code ready to roll. It's like having a buddy who writes code while you munch on snacks!

Polishing Your Data Scooper

Crafting a web scraper is kinda like brewing the perfect cup of coffee. It needs a little tinkering to hit that sweet spot between speed and accuracy. With Cheerio, Node.js, and a little help from ChatGPT, you’ve got a solid start. Don’t forget to handle those pesky paginations, asynchronous loads, and rate limits to scrape like a pro!😎

Further

You need to make data useful! at bytebricks we build using a Laravel backend and a Vue front, we find that fast to market and Laravel using SQL have a low ongoing overhead cost! not to mention the magic of Eloquent as in this example of whereHas or the very easy integration of AWS SES!

Integrating AWS Simple Email Service (SES) with Laravel: A Comprehensive Guide

ByteBricks.ai — Tue, 26 Sep 2023 19:25:47 +0000

AWS Simple Email Service (SES) has carved a niche for itself as a potent solution for delivering transactional emails, promotional content, and we use that service as a primary provider on bytebricks.ai delivering our emails and customers emails as well.

Marrying AWS SES with Laravel (we are big fans) opens the doors to efficient email management, high deliverability rates, and cost-effective solutions.

This article is a dive into how to seamlessly integrate AWS SES with a Laravel application, the advantages of this integration, and hands-on steps with relevant code blocks. As an icing on the cake, our subsequent article will explore the nuances of AWS Simple Notification Service (SNS). Let’s embark on this journey!

Advantages of Using AWS SES in Laravel Applications:

Cost-Effective Solution: Unlike traditional systems that come with hidden fees or fixed monthly costs, SES operates on a pay-as-you-go model. This is especially beneficial for startups and mid-sized businesses that are budget-conscious.
Incredible Scalability: Leveraging Amazon's renowned infrastructure, SES promises high deliverability rates, even when you're sending out a massive volume of emails. This scalability ensures that as your business grows, your email solution grows with you.
Unwavering Reliability: Built on the bedrock of Amazon's robust infrastructure, SES ensures that your emails don’t just end up in the abyss but reach your intended recipients.
Seamless Integration: SES can be effortlessly coupled with other AWS services. Imagine integrating SES with SNS for real-time notifications or AWS Lambda for serverless code execution.
Stringent Security Measures: AWS leaves no stone unturned in ensuring your emails are encrypted end-to-end. This guarantees that your sensitive emails are shielded from prying eyes during transit.

Hands-on Integration of AWS SES with Laravel:

Setting Up AWS SES:

Manage Your AWS Resources:

To kickstart your journey, sign into the AWS Management Console.

Verify an Email Address:

Before you venture into sending emails, AWS mandates the verification of your email address with SES. This is a security measure to confirm that you have rightful access to the sender's email address.

Initiate Email Sending:

With your email now verified, the gates are open to send emails. SES offers three avenues: the console, SMTP interface, or the API. For Laravel aficionados, the API is your best bet.

Integrate SES with Laravel:

Installation: The first step is to bring the AWS SDK for PHP onboard. This can be achieved with composer:

composer require aws/aws-sdk-php

Configuration:

With the SDK in place, the next step is to etch your AWS credentials in the .env file.

AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
AWS_DEFAULT_REGION=your_region

Laravel Mail Configuration:

Modify the mail.php configuration file to employ SES as your mail driver.

'mail' => [
    'driver' => 'ses',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION')
]

Crafting and Sending Emails:

Laravel’s innate Mail facade is your trusted ally in sending emails. With SES as the driver, the process remains seamless.

use Illuminate\Support\Facades\Mail;

Mail::send('emails.test', ['user' => $user], function ($m) use ($user) {
    $m->to($user->email, $user->name)->subject('AWS SES Test!');
});

Monitoring Your Emails:

AWS SES isn’t just about sending emails. It’s also about ensuring they reach the promised land. SES provides tools to monitor metrics like delivery rates, bounce rates, and complaints.

$metrics = SES::getMetrics();
echo $metrics['DeliveryRate'];

Handling Bounces & Complaints:
Here’s where the magic of AWS SNS will come into play. SNS ensures you're instantly notified about pivotal email events such as bounces or complaints. However, the nitty-gritty of AWS SNS will be the highlight of our next article.

In Conclusion:

The synergy between AWS SES and Laravel promises an unparalleled email experience. With SES’s cost efficiency, scalability, and reliability coupled with Laravel’s simplicity, developers can effortlessly send, manage, and monitor emails.

Happy coding, and see you in the world of AWS SNS notifications! 🚀👨‍💻

Unleashing the Power of whereHas in Laravel

ByteBricks.ai — Mon, 25 Sep 2023 01:06:36 +0000

Hello, wonderful dev.to community! As a senior developer who's been working with Laravel for quite some time, I've come to appreciate the nuances and powerful features it offers. Today, I want to talk about a hidden gem: the whereHas method. This method provides a clean, elegant way to filter results based on relationship constraints.

What is whereHas?

In Laravel, relationships are a cornerstone of Eloquent ORM. However, sometimes we need to filter the results of our primary model based on the presence or properties of a related model.

In a nutshell, whereHas lets you apply conditions to your Eloquent queries based on related model data, we used that over and over building our API at Bytebricks.ai.

A Simple Example

Imagine we have a Post model and each Post can have many Comment models. Now, let's say we want to fetch all posts that have at least one comment. With whereHas, this is a breeze:

$postsWithComments = Post::whereHas('comments')->get();

Diving Deeper

What if we want to fetch posts with comments from a specific user? With whereHas, you can provide a closure to add additional constraints:

$userId = 1;
$postsWithCommentsFromUser = Post::whereHas('comments', function ($query) use ($userId) {
    $query->where('user_id', $userId);
})->get();

Counting Related Models

whereHas can also be used with the withCount method to get the number of related models:

$posts = Post::withCount('comments')->get();

foreach ($posts as $post) {
    echo $post->comments_count;
}

Performance Tips

While whereHas is powerful, be mindful of the N+1 problem. Ensure you're using methods like with() to eager-load relationships when needed. The Laravel Debugbar is a great tool for keeping an eye on your queries.

Conclusion

whereHas is a testament to the flexibility and power that Laravel's Eloquent offers. When used wisely, it can make your database queries clean, intuitive, and efficient.

I hope you found this deep dive helpful. Always remember to optimize your queries and use the tools at your disposal to ensure the best performance. Happy coding, and stay curious!

Dont miss the Laravel AWS SES Tutorial

Resources
Laravel Docs
Great video explaining usage