Imagine you're in the middle of an important Zoom call — and suddenly your internet cuts out. Your heart skips a beat. That dreaded buffering circle spins on the screen. You're disconnected.

Now imagine instead: the internet switches seamlessly to a backup connection. Your meeting continues without a glitch.

That’s the power of failover internet. In this guide, I’ll show you how I used Starlink as primary internet and a local ISP via PPPoE as backup, with the help of a MikroTik router — and how you can do the same.

Whether you work from home, stream content, or run a smart home — this setup adds peace of mind and productivity.

🧰 Hardware I Used

• MikroTik hEX S (RB760iGS) — compact and powerful router

• TP-Link Deco M4 Mesh (3 units) — for strong Wi-Fi across the house

• Windows PC — for initial configuration

⚙️ The Big Picture

We’ll configure:

• Starlink (ether1) as the main internet (DHCP)

• Local ISP (ether2) using PPPoE as backup

• Failover logic so the router automatically switches when Starlink fails

• LAN setup with DHCP + NAT

• Optional: MAC spoofing, DNS, and firewall basics

🪜 Step-by-Step Setup (Beginner Friendly)

🔌 Step 1: Connect to Your MikroTik Router

1. Plug your Windows PC into ether2–ether5 on the MikroTik router (avoid ether1 — that’s for internet input).

2. On Windows, open ncpa.cpl, select your Ethernet adapter > Properties > TCP/IPv4 → Set to “Obtain IP automatically”.

3. Your PC should get an IP like 192.168.88.x.

💻 Step 2: Login to MikroTik via Winbox

1. Download Winbox from: mikrotik.com/download

2. Open it — no install needed.

3. Look under the Neighbors tab — you’ll see your router’s MAC and IP (192.168.88.1)

4. Connect using:

   • Username: admin

   • Password: (Check router label or leave blank for first login)

5. Click Connect

🔧 Step 3: Initial Router Setup

1. Change the admin password

   • Go to: System > Users > admin > Set Password

2. Update RouterOS

   • Go to: System > Packages > Check for Updates > Download & Install

   • Channel: stable

Router will reboot. Reconnect after that.

🌐 WAN Configuration

🔌 Step 4: Connect WAN Sources

🚀 Step 5: Set Starlink as Primary WAN

1. Go to IP > DHCP Client

2. Click +

3. Set Interface to ether1

4. Click Apply and **OK`

✅ Starlink will now get a dynamic IP as your primary internet.

🌍 Step 6: Set Up ISP as Backup via PPPoE

1. Go to Interfaces > + > PPPoE Client

2. Set:

   • Name: pppoe-out1

   • Interface: ether2

3. In Dial Out tab:

   • Username: your-pppoe-username

   • Password: your-password

   • Enable: Add Default Route

   • Set Default Route Distance: 2

4. Apply and OK

✅ This ensures PPPoE acts as a failover connection (lower priority than Starlink).

📶 Step 7: LAN Setup (Home Devices)

1. Go to Bridge > Add New Bridge

2. Add ether3 to ether5 to the bridge

3. Go to IP > DHCP Server > Setup

   • Choose bridge as interface

   • Set default IP range (e.g., 192.168.88.0/24)

4. Go to IP > Firewall > NAT

   • Add masquerade rules for:

     • • Out Interface: ether1 → Action: masquerade

         • Out Interface: pppoe-out1 → Action: masquerade

✅ Now all LAN devices can share internet via both connections.

🧠 Step 8: Failover in Action

Go to IP > Routes — you should see:

• Starlink → distance 1

• PPPoE → distance 2

If Starlink fails, MikroTik auto-switches to the PPPoE route.

💡 Warm failover: It’s fast, not instant. No downtime for most tasks (buffering may happen once).

🧪 Advanced Tips (Optional but Useful)

🔄 Script-Based Netwatch (For Active Failover)

If you want faster detection, set up Netwatch:

• Go to Tools > Netwatch

• Monitor a reliable IP (e.g., 8.8.8.8)

• On Down, disable Starlink route

• On Up, re-enable it

🧙 Spoof MAC Address (If ISP Locks It)

Some ISPs only allow internet on registered MACs.

To clone MAC on ether2:

/interface ethernet set ether2 mac-address=XX:XX:XX:XX:XX:XX

Then confirm under Interfaces > ether2

🌐 Setup DNS

1. Go to IP > DNS

2. Add:

   • 8.8.8.8 (Google)

   • 1.1.1.1 (Cloudflare)

3. Enable Allow Remote Requests

✅ This helps your LAN devices resolve domains via MikroTik.

🎉 You Did It!

You now have a smart home internet setup with:

✅ Primary internet from Starlink
✅ Automatic failover to ISP (PPPoE)
✅ Seamless recovery when Starlink is back
✅ Stable internet for work, video calls, gaming, and streaming

👨‍💻 Real Life Example: Why I Needed This

I live in a semi-urban area where power cuts or weather often interrupt traditional ISP service. Starlink provides excellent uptime — but even satellite can sometimes drop.

Thanks to this setup, when Starlink stutters, my MikroTik router quietly shifts over to my ISP. I keep working, the Netflix show doesn’t stop, and my smart lights stay responsive.

It’s like having internet insurance — and it’s worth every minute of setup.

🧭 What’s Next?

Now that you're comfortable with MikroTik basics, you can explore:

• 🔐 Firewall rules

• 🎛️ Bandwidth control

• 🧅 VPN access to your home

• 🧰 Remote monitoring and management

💬 Questions or Feedback?

Drop a comment below if you run into any issues or want me to cover more advanced MikroTik topics. Happy networking!

Hey friend! 👋
You've built your awesome Next.js app and now you're ready to show it off to the world. But… you're on cPanel hosting and not sure what to do next?

No worries—I’ll walk you through everything like we’re sitting side by side. ☕️
This guide is perfect for beginners who are trying to deploy a Next.js app on cPanel the smart way.

🧰 What You’ll Need First

Before diving in, make sure you’ve got:

• ✅ A Next.js app (already created and tested locally)

• ✅ A cPanel-based hosting account (shared or VPS)

• ✅ A domain name connected to your cPanel

Optional but helpful: Basic knowledge of how file managers and terminal commands work.

⚠️ A Quick Note About npm vs yarn

These are two different package managers that do the same job: they install and run packages (like Next.js, React, etc.).

🟢 If you used npm to create your project, keep using npm.

🔵 If you used yarn to create your project, stick with yarn.

Do NOT use both. Pick the one you started with and use only that throughout the guide.

🛠 Step 1: Create a Custom Server File

Most Next.js apps are designed to be run on Vercel or similar platforms. But since we’re on cPanel, we need a custom server using Node.js.

➕ In your project root, create a new file manually named server.js or from the terminal using the below command:

touch server.js

Paste this code into server.js:

const { createServer } = require('http')
const { parse } = require('url')
const next = require('next')

const dev = process.env.NODE_ENV !== 'production'
const hostname = 'localhost'
const port = process.env.PORT || 3000

const app = next({ dev, hostname, port })
const handle = app.getRequestHandler()

app.prepare().then(() => {
  createServer(async (req, res) => {
    try {
      const parsedUrl = parse(req.url, true)
      await handle(req, res, parsedUrl)
    } catch (err) {
      console.error('Error occurred handling', req.url, err)
      res.statusCode = 500
      res.end('internal server error')
    }
  }).listen(port, (err) => {
    if (err) throw err
    console.log(`> Ready on http://${hostname}:${port}`)
  })
})

This file is like the traffic cop for your app, making sure every request gets routed properly.

🧾 Step 2: Update Your package.json

Tell your app how to start in production using the server you just created.

Open your package.json file and change the scripts section like this:

"scripts": {
  //... Do not change other commands just the "start" command
  "start": "NODE_ENV=production node server.js"
}

This will allow you to run npm start or yarn start later, depending on your package manager.

🧱 Step 3: Build Your App

We need to prepare your app for production (i.e., make it fast and optimized).

👉 If you’re using npm, run:

npm run build

👉 If you’re using yarn, run:

yarn build

This will generate a .next folder containing the production-ready version of your app.

📦 Step 4: Zip Your App for Upload

You now need to package your app (without the junk) to upload to cPanel.

✅ Select all project files except:

• node_modules/

• .git/

• .gitignore

• README.md

📁 Then compress everything into a .zip file.

You can name it nextjs-app.zip or anything you like.

📂 Step 5: Upload and Extract on cPanel

1. Log into your cPanel dashboard

2. Open the File Manager

3. Navigate to the directory where your domain lives (usually public_html/)

4. Upload your .zip file

5. Once uploaded, right-click the file and select Extract

You should now see all your app files inside the correct folder.

⚙️ Step 6: Set Up the Node.js App in cPanel

1. Scroll down to the Software section in cPanel

2. Click on Setup Node.js App

3. Click Create Application

Fill in the following:

• Node.js version: Choose the one that matches your development environment (e.g., 22.x)

• Application mode: Production

• Application root: The folder where your files were extracted (e.g., public_html/nextjs-app)

• Application URL: Your domain or subdomain

• Application startup file: server.js

Now hit Create—cPanel will set up the environment for your app.

📥 Step 7: Install Project Dependencies

Your app needs packages (like Next.js, React, etc.) to run. Time to install them.

👉 Option 1: Use the cPanel GUI

1. Go to your Node.js App list

2. Click Stop App (temporarily stop it)

3. Scroll down and click Run NPM Install

If you used npm when creating the app, this is perfect. If you used yarn, you'll need to install via SSH (next step).

👉 Option 2: Use SSH (for Yarn users or advanced installs)

If your hosting allows SSH access:

cd ~/public_html/your-app-folder

Then install packages:

For npm users:

npm install

For yarn users:

yarn install

Once complete, go back to cPanel and click Start App again.

🎉 Step 8: You’re Live!

Open your browser, type your domain, and hit Enter…
If all went well—you’re now serving your beautiful Next.js app to the world!

🧠 Final Thoughts

Deploying on cPanel might seem scary at first, especially if you're used to platforms like Vercel. But with a little effort, it works beautifully—even on shared hosting.

🔁 Quick Recap:

• Created a custom server.js

• Built the app

• Zipped and uploaded files

• Set up Node.js on cPanel

• Installed dependencies using either npm or yarn

• And finally—ran the app!

💬 Got Questions?

Drop them in the comments or reach out to me! I'm happy to help you troubleshoot or celebrate your deployment success 🚀

Happy coding! 🎉💻

This blog is inspired from:

In the ever-evolving world of software development, the right tools can make the difference between a good developer and a great one. Visual Studio Code has become my go-to integrated development environment, and over time, I've curated a collection of extensions that have transformed my coding experience, boosting productivity, improving code quality, and making development more enjoyable.

How I’ve created this blog?

Here is script and the steps: https://gist.github.com/sohag-pro/f17a6d02514f9260811614e2db5175d4

The Extensions That Power My Development

Bookmarks

Publisher: Alessandro Fragnani

Description: Mark lines and jump to them

Marketplace Link

Laravel Extra Intellisense

Publisher: amir

Description: better intellisense for laravel projects.

Marketplace Link

All Autocomplete

Publisher: Atishay Jain

Description: Create autocomplete items from open files in VSCode.

Marketplace Link

Tailwind Docs

Publisher: Austen Cameron

Description: Easily access the Tailwind CSS documentation from within Code

Marketplace Link

JSON Crack

Publisher: Aykut Saraç

Description: Seamlessly visualize your JSON data instantly into graphs.

Marketplace Link

PHP Intelephense

Publisher: Ben Mewburn

Description: PHP code intelligence for Visual Studio Code

Marketplace Link

Tailwind Shades

Publisher: Omar Bourhaouta

Description: Tailwind CSS color palette generator

Marketplace Link

Tailwind CSS IntelliSense

Publisher: Tailwind Labs

Description: Intelligent Tailwind CSS tooling for VS Code

Marketplace Link

Turbo Console Log

Publisher: Anas Chakroun

Description: Automating the process of writing meaningful log messages.

Marketplace Link

gitignore

Publisher: CodeZombie

Description: Lets you pull .gitignore templates from the https://github.com/github/gitignore repository. Language support for .gitignore files.

Marketplace Link

Laravel goto view

Publisher: codingyu

Description: Quick jump to view

Marketplace Link

Dart

Publisher: Dart Code

Description: Dart language support and debugger for Visual Studio Code.

Marketplace Link

Flutter

Publisher: Dart Code

Description: Flutter support and debugger for Visual Studio Code.

Marketplace Link

ESLint

Publisher: Microsoft

Description: Integrates ESLint JavaScript into VS Code.

Marketplace Link

Composer

Publisher: DEVSENSE

Description: All-in-One composer integration, quick actions, commands, automatic installation, tasks, code lenses, diagnostics, and composer.json IntelliSense.

Marketplace Link

IntelliPHP - AI Autocomplete for PHP

Publisher: DEVSENSE

Description: AI-assisted development for PHP.

Marketplace Link

PHP

Publisher: DEVSENSE

Description: All-in-One PHP support - IntelliSense, Debug, Formatter, Code Lenses, Code Fixes, Linting, Refactoring, PHPUnit Tests, Web Server, and more.

Marketplace Link

PHP Profiler

Publisher: DEVSENSE

Description: Support for PHP (Xdebug) profiling files and inspecting them.

Marketplace Link

GitLens — Git supercharged

Publisher: GitKraken

Description: Supercharge Git within VS Code - Visualize code authorship at a glance via Git blame annotations and CodeLens, seamlessly navigate and explore Git repositories, gain valuable insights via rich visualizations and powerful comparison commands, and so much more

Marketplace Link

goto-route-controller-laravel

Publisher: Erlang Parasu

Description: laravel helper: go to route declaration, go to controller method declaration, find blade usage

Marketplace Link

Prettier - Code formatter

Publisher: Prettier

Description: Code formatter using prettier

Marketplace Link

Auto Rename Tag

Publisher: Jun Han

Description: Auto rename paired HTML/XML tag

Marketplace Link

OpenSSL Configuration Syntax

Publisher: geeksharp

Description: Syntax highlighting for OpenSSL configuration files (openssl.cnf)

Marketplace Link

GitHub Copilot

Publisher: GitHub

Description: Your AI pair programmer

Marketplace Link

GitHub Copilot Chat

Publisher: GitHub

Description: AI chat features powered by Copilot

Marketplace Link

GitHub Actions

Publisher: GitHub

Description: GitHub Actions workflows and runs for github.com hosted repositories in VS Code

Marketplace Link

GitHub Pull Requests

Publisher: GitHub

Description: Pull Request and Issue Provider for GitHub

Marketplace Link

Todo Tree

Publisher: Gruntfuggly

Description: Show TODO, FIXME, etc. comment tags in a tree view

Marketplace Link

HashiCorp Terraform

Publisher: HashiCorp

Description: Syntax highlighting and autocompletion for Terraform

Marketplace Link

Laravel Blade Wrapper

Publisher: IHunte

Description: An extension to wrap Blade directives

Marketplace Link

Hungry Delete

Publisher: jasonlhy

Description: To delete an entire block of whitespace or tab, and reduce the time programmers need to press backspace

Marketplace Link

lzgit

Publisher: jlalmes

Description: LaZyGIT - FOR HYPER EFFICIENT DEVELOPERS.

Marketplace Link

Peacock

Publisher: John Papa

Description: Subtly change the workspace color of your workspace. Ideal when you have multiple VS Code instances and you want to quickly identify which is which.

Marketplace Link

colorize

Publisher: kamikillerto

Description: A vscode extension to help visualize css colors in files.

Marketplace Link

phpfmt - PHP formatter

Publisher: kokororin

Description: Integrates phpfmt into VS Code

Marketplace Link

Laravel

Publisher: Laravel

Description: Official VS Code extension for Laravel

Marketplace Link

GPG Sign

Publisher: Mário Garrido

Description: GPG Encrypter/Decrypter/Sign

Marketplace Link

PHP Namespace Resolver

Publisher: Mehedi Hassan

Description: Import and expand php namespaces

Marketplace Link

Fluent Icons

Publisher: Miguel Solorio

Description: Fluent product icons for Visual Studio Code

Marketplace Link

Remote - SSH

Publisher: Microsoft

Description: Open any folder on a remote machine using SSH and take advantage of VS Code's full feature set.

Marketplace Link

Remote - SSH: Editing Configuration Files

Publisher: Microsoft

Description: Edit SSH configuration files

Marketplace Link

Remote Explorer

Publisher: Microsoft

Description: View remote machines for SSH and Tunnels.

Marketplace Link

Paste Image

Publisher: mushan

Description: paste image from clipboard directly

Marketplace Link

laravel-goto-components

Publisher: naoray

Description: Quick jump to components

Marketplace Link

Back & Forth

Publisher: Nick Rudenko

Description: Adds go back/forward buttons for easier navigation

Marketplace Link

indent-rainbow

Publisher: oderwat

Description: Makes indentation easier to read

Marketplace Link

Laravel Blade Snippets

Publisher: Winnie Lin

Description: Laravel blade snippets and syntax highlight support

Marketplace Link

Laravel Extension Pack

Publisher: Winnie Lin

Description: A collection of extensions for Laravel development

Marketplace Link

Laravel Snippets

Publisher: Winnie Lin

Description: Laravel snippets for Visual Studio Code (Support Laravel 5 and above)

Marketplace Link

Laravel Pint

Publisher: Open Southeners

Description: Integrates Laravel Pint into your VSCode projects for automatic code formatting

Marketplace Link

ChatGPT – Work with Code on macOS

Publisher: OpenAI

Description: Allows the ChatGPT desktop application to read and edit files open in Visual Studio Code. It requires the ChatGPT desktop app to function.

Marketplace Link

laravel-jump-controller

Publisher: pgl

Description: Alt + click to navigate from a route to a respective controller file

Marketplace Link

Material Icon Theme

Publisher: Philipp Kief

Description: Material Design Icons for Visual Studio Code

Marketplace Link

Toggle Case

Publisher: Pranshu Agrawal

Description: Toggle through various cases on a key press

Marketplace Link

XML

Publisher: Red Hat

Description: XML Language Support by Red Hat

Marketplace Link

YAML

Publisher: Red Hat

Description: YAML Language Support by Red Hat, with built-in Kubernetes syntax support

Marketplace Link

Live Server

Publisher: Ritwick Dey

Description: Launch a development local Server with live reload feature for static & dynamic pages

Marketplace Link

Laravel Artisan

Publisher: Ryan Naddy

Description: Run Laravel Artisan commands within Visual Studio Code

Marketplace Link

Git Merger

Publisher: Shahar Kazaz

Description: Simplifies the git merge process

Marketplace Link

Markdown Preview Enhanced

Publisher: Yiyi Wang

Description: Markdown Preview Enhanced ported to vscode

Marketplace Link

vue-helper

Publisher: shenjiaolong

Description: vue enhance, extension for Element-UI, Element Plus, Ant Desigin Vue

Marketplace Link

Laravel Blade formatter

Publisher: Shuhei Hayashibara

Description: Laravel Blade formatter for VSCode

Marketplace Link

Rewrap

Publisher: stkb

Description: Hard word wrapping for comments and other text at a given column.

Marketplace Link

Code Spell Checker

Publisher: Street Side Software

Description: Spelling checker for source code

Marketplace Link

Window Colors

Publisher: Stuart Robinson

Description: Automatically adds a unique color to each window's activityBar and titleBar.

Marketplace Link

vscode-pdf

Publisher: tomoki1207

Description: Display pdf file in VSCode.

Marketplace Link

Vue - Official

Publisher: Vue

Description: Language Support for Vue

Marketplace Link

Git Blame

Publisher: Wade Anderson

Description: See git blame information in the status bar.

Marketplace Link

vscode-js-import

Publisher: wangtao0101

Description: Intelligent and fast import extension for js in vscode, support import position option and adding import to existing import statement.

Marketplace Link

TODO Highlight

Publisher: Wayou Liu

Description: highlight TODOs, FIXMEs, and any keywords, annotations...

Marketplace Link

git-configure

Publisher: windsonR

Description: In vscode, config GPG key to git config

Marketplace Link

JavaScript (ES6) code snippets

Publisher: charalampos karypidis

Description: Code snippets for JavaScript in ES6 syntax

Marketplace Link

PHP Debug

Publisher: Xdebug

Description: Debug support for PHP with Xdebug

Marketplace Link

vue-component

Publisher: zhubincong

Description: Use vue components easily

Marketplace Link

Vue

Publisher: Rahul Kadyan

Description: Syntax Highlight

Marketplace Link

PHP IntelliSense

Publisher: Damjan Cvetko

Description: Advanced Autocompletion and Refactoring support for PHP

Marketplace Link

Why These Extensions Matter

Each of these extensions has been carefully selected to address specific pain points in my development process. From code formatting and intellisense to version control and productivity tools, they work together to create a seamless and efficient coding environment.

Key benefits include:

• Enhanced code quality

• Improved developer productivity

• Simplified workflow

• Better code navigation and understanding

• Advanced debugging capabilities

Final Thoughts

Developing software is not just about writing code; it's about creating an environment that allows you to do your best work. These VSCode extensions are more than just tools—they're collaborative partners that help me write cleaner, more efficient code.

Pro Tip: Remember that the perfect development setup is personal. What works for me might need tweaking to suit your specific workflow. Don't be afraid to experiment and find the extensions that resonate with your coding style.

Happy coding! 🚀👩‍💻👨‍💻

What We're Building Today

Imagine being able to build your own digital neighborhood, complete with public areas, private spaces, and secure entrances - all perfectly organized for safety, efficiency, and growth. That's exactly what we'll be doing in AWS today!

By the end of this tutorial, you will have created:

• A secure, isolated cloud network (VPC)

• Public and private areas (subnets) in different locations (availability zones)

• Safe entrances and exits to the internet (gateways)

• Traffic rules to keep everything running smoothly (route tables)

Whether you're just starting your cloud journey or looking to strengthen your AWS fundamentals, this guide will walk you through creating a production-ready network architecture using simple, everyday analogies.

Why Do We Need This?

Before we start building, let's understand why this matters:

1. Security: Just like you wouldn't want strangers wandering through your bedroom, some parts of your application (like databases) should be kept private.

2. Reliability: If one neighborhood (availability zone) experiences a power outage, your application can still run in another neighborhood.

3. Organization: Good fences make good neighbors! Properly separating your resources makes them easier to manage.

4. Scalability: A well-planned network gives your applications room to grow.

Now, let's start building our cloud neighborhood!

Step 1: Creating Your VPC (Your Digital Property)

Think of a VPC as buying a large plot of land where you'll build your digital home. You need to decide how big it should be and establish the boundaries.

Here's what to do:

1. Sign in to the AWS Management Console

2. Navigate to "VPC" under Services

3. Click "Create VPC"

4. Fill in these details:

   • Name: MyDigitalNeighborhood

   • IPv4 CIDR block: 10.0.0.0/16

   • Leave other settings as default

5. Click "Create VPC"

Understanding CIDR: The Magic Behind IP Addressing

Imagine the internet as a giant city with billions of houses (computers), and each house needs a unique address (IP address). CIDR (Classless Inter-Domain Routing) is the clever system we use to organize these addresses.

What the Numbers Mean

The CIDR notation like 10.0.0.0/16 has two important parts:

• The first part (10.0.0.0) is the starting address of your neighborhood

• The second part (/16) tells us how many addresses belong to you

The number after the slash (/16) represents how many bits in the IP address are fixed for your network. An IP address has 32 bits total, so:

• /16 means 16 bits are fixed, leaving 16 bits for your addresses (2^16 = 65,536 addresses)

• /24 means 24 bits are fixed, leaving only 8 bits for your addresses (2^8 = 256 addresses)

• /28 means 28 bits are fixed, leaving just 4 bits for your addresses (2^4 = 16 addresses)

How to Calculate Available Addresses

Here's a simple way to calculate how many addresses you get:

1. Take the number after the slash (let's call it N)

2. Subtract it from 32 (32 - N)

3. Raise 2 to that power: 2^(32-N)

Examples:

• For /16: 2^(32-16) = 2^16 = 65,536 addresses

• For /24: 2^(32-24) = 2^8 = 256 addresses

• For /28: 2^(32-28) = 2^4 = 16 addresses

Address Range Calculation

To find the range of addresses in a CIDR block:

• Starting address: The address you specified (e.g., 10.0.0.0)

• Ending address: Add your total number of addresses to the starting address, then subtract 1

For 10.0.0.0/16:

• Starting: 10.0.0.0

• Ending: 10.0.0.0 + 65,536 - 1 = 10.0.255.255

For 10.0.1.0/24:

• Starting: 10.0.1.0

• Ending: 10.0.1.0 + 256 - 1 = 10.0.1.255

Practical Tips for CIDR Planning

1. Start Bigger Than You Need: It's easier to subnet a large network than to expand a small one. Begin with a /16 for your VPC if possible.

2. Use Powers of 2: Always create subnets with sizes that are powers of 2 (256, 512, 1024, etc.). This keeps your CIDR math clean.

3. Mind Your Zeros: When creating a subnet, make sure the network address ends with the right number of zeros. For example, a /24 network must end with one zero (like 10.0.1.0).

4. Leave Room for Growth: Don't make your subnets too small. If you think you need 100 addresses, use a /24 (256 addresses) rather than a /25 (128 addresses).

5. CIDR Cheat Sheet:

   • /16 = 65,536 addresses (large VPC)

   • /20 = 4,096 addresses (medium subnet)

   • /24 = 256 addresses (standard subnet)

   • /28 = 16 addresses (small subnet)

   • /32 = 1 address (single IP)

Think of CIDR like buying land: the smaller the number after the slash, the larger your property! A /16 is like owning a whole county, while a /24 is more like owning a city block.

Step 2: Creating Subnets (Neighborhoods within Your Property)

Now that we have our land, let's divide it into different areas - some public (like front yards) and some private (like backyards). And we'll create these areas in different locations (availability zones) for safety.

Here's what to do:

Public Subnet in First Location (AZ-1)

1. In the VPC Dashboard, click "Subnets"

2. Click "Create subnet"

3. Configure:

   • VPC: Select your MyDigitalNeighborhood

   • Name: FrontYard-East

   • Availability Zone: Select the first AZ (e.g., us-east-1a)

   • CIDR block: 10.0.1.0/24

4. Click "Create"

Private Subnet in First Location (AZ-1)

1. Click "Create subnet" again

2. Configure:

   • VPC: Same VPC

   • Name: BackYard-East

   • Availability Zone: Same as above (e.g., us-east-1a)

   • CIDR block: 10.0.2.0/24

3. Click "Create"

Public Subnet in Second Location (AZ-2)

1. Click "Create subnet" again

2. Configure:

   • VPC: Same VPC

   • Name: FrontYard-West

   • Availability Zone: Select a different AZ (e.g., us-east-1b)

   • CIDR block: 10.0.3.0/24

3. Click "Create"

Private Subnet in Second Location (AZ-2)

1. Click "Create subnet" again

2. Configure:

   • VPC: Same VPC

   • Name: BackYard-West

   • Availability Zone: Same as above (e.g., us-east-1b)

   • CIDR block: 10.0.4.0/24

3. Click "Create"

Why We Did It This Way:

Think of this like building a house with front yards (public subnets) and backyards (private subnets) in two different neighborhoods (availability zones).

• Front yards (public subnets) are visible from the street and accessible to visitors

• Backyards (private subnets) are more secure and not directly accessible from the street

• Building in two neighborhoods (AZs) means if one has a problem (like a power outage), you can still use the other

Step 3: Creating an Internet Gateway (Your Main Entrance)

Now we need a way for people to enter and exit our property from the main road (internet). This is our Internet Gateway.

Here's what to do:

1. In the VPC Dashboard, click "Internet Gateways"

2. Click "Create internet gateway"

3. Name it MainEntrance

4. Click "Create"

5. Select your new gateway and click "Actions" > "Attach to VPC"

6. Select your VPC and click "Attach"

Why We Need This:

Just like your house needs a front door to let people in and out, your VPC needs an Internet Gateway to allow traffic between your resources and the internet. Without it, your public resources would be isolated from the outside world!

Step 4: Creating a NAT Gateway (Your Service Entrance)

Now, things in our backyard (private subnets) need a way to access the internet for updates and downloads, but we don't want strangers coming in through this door. That's what a NAT Gateway is for.

Here's what to do:

1. In the VPC Dashboard, click "NAT Gateways"

2. Click "Create NAT gateway"

3. Configure:

   • Name: ServiceEntrance

   • Subnet: Select one of your public subnets (e.g., FrontYard-East)

   • Connectivity: Public

   • Elastic IP: Click "Allocate Elastic IP"

4. Click "Create NAT gateway"

Why We Need This:

Imagine your private backyard has plants that need water (updates from the internet). The NAT Gateway is like a gardener who can go out to get water and bring it back, but strangers can't use this entrance to come in uninvited. This way, your private resources can access the internet without being exposed to it.

Step 5: Setting Up Route Tables (Traffic Rules)

Now we need to create rules about how traffic should flow in our neighborhoods.

Public Route Table (Rules for Front Yards)

1. Go to "Route Tables" in the VPC Dashboard

2. Click "Create route table"

3. Configure:

   • Name: FrontYard-Rules

   • VPC: Your VPC

4. Click "Create"

5. Select the new route table

6. Go to "Routes" tab and click "Edit routes"

7. Click "Add route"

   • Destination: 0.0.0.0/0 (everywhere on the internet)

   • Target: Select your Internet Gateway

8. Click "Save changes"

9. Go to "Subnet associations" tab

10. Click "Edit subnet associations"

11. Select both your public subnets (FrontYard-East and FrontYard-West)

12. Click "Save associations"

Private Route Table (Rules for Back Yards)

1. Click "Create route table" again

2. Configure:

   • Name: BackYard-Rules

   • VPC: Your VPC

3. Click "Create"

4. Select this new route table

5. Go to "Routes" tab and click "Edit routes"

6. Click "Add route"

   • Destination: 0.0.0.0/0 (everywhere on the internet)

   • Target: Select your NAT Gateway

7. Click "Save changes"

8. Go to "Subnet associations" tab

9. Click "Edit subnet associations"

10. Select both your private subnets (BackYard-East and BackYard-West)

11. Click "Save associations"

Why We Did It This Way:

Think of route tables like giving directions to visitors:

• The public route table says: "To get to the internet, use the main entrance (Internet Gateway)"

• The private route table says: "To get to the internet, use the service entrance (NAT Gateway)"

This ensures traffic flows exactly how we want it to: public resources can communicate directly with the internet, while private resources can only send requests out through the NAT Gateway.

Step 6: Enabling Auto-assign Public IP for Public Subnets

Our front yards need addresses that are visible from the street.

Here's what to do:

1. Go to "Subnets" in the VPC Dashboard

2. Select your first public subnet (FrontYard-East)

3. Click "Actions" > "Edit subnet settings"

4. Check "Enable auto-assign public IPv4 address"

5. Click "Save"

6. Repeat for your second public subnet (FrontYard-West)

Why We Need This:

This is like putting a house number on your mailbox so people can find you. Without a public IP address, resources in your public subnets wouldn't be reachable from the internet.

What We've Built: The Big Picture

Congratulations! You've now built a complete cloud network architecture. Let's review what we have:

1. A VPC (10.0.0.0/16): Your digital property with 65,536 possible addresses

2. Four Subnets:

   • Two public "front yards" (10.0.1.0/24 and 10.0.3.0/24)

   • Two private "back yards" (10.0.2.0/24 and 10.0.4.0/24)

   • Located in two different neighborhoods (availability zones)

3. Gateways:

   • An Internet Gateway (main entrance)

   • A NAT Gateway (service entrance)

4. Route Tables:

   • Public routes for front yards

   • Private routes for back yards

Real-World Application

Now that our cloud neighborhood is built, here's how you might use it:

• Public Subnets (Front Yards): Place web servers, load balancers, and public-facing applications here

• Private Subnets (Back Yards): Place databases, application servers, and other sensitive resources here

• Multiple AZs (Different Neighborhoods): Ensures your application stays running even if one area has problems

Conclusion

Building a VPC architecture might seem complicated at first, but when you break it down into simple concepts like yards, entrances, and traffic rules, it becomes much clearer.

This architecture follows AWS best practices and gives you a solid foundation for hosting applications securely in the cloud. As your needs grow, you can expand this architecture by adding more subnets or connecting to other VPCs.

Remember: in the cloud, good fences (network boundaries) really do make good neighbors (secure applications)!

Now go ahead and start placing your resources in your new cloud home. Your web servers will enjoy the view from the front yard, while your databases can relax securely in the backyard!

Have you ever felt overwhelmed by the alphabet soup of AWS networking terms? You're not alone! As a cloud newcomer, understanding terms like VPC, CIDR, and NAT Gateway can feel like learning a foreign language. In this beginner-friendly guide, I'll break down these intimidating acronyms into simple concepts you can relate to in everyday life.

VPC (Virtual Private Cloud)

What it is: A VPC is your own private section of the AWS cloud where you can place your resources (like servers and databases).

Real-life analogy: Think of a VPC as your own private property or gated community. Just like you'd build different structures on your property (house, garage, garden shed), you can place different AWS resources in your VPC. And just as you decide who can enter your property, you control who can access your VPC.

Why it matters: VPCs isolate your resources from other AWS customers, providing security and organization. You get to define your own network rules, just like you would set house rules for your home.

CIDR (Classless Inter-Domain Routing)

What it is: CIDR is a method for allocating IP addresses and routing network traffic.

Real-life analogy: Imagine a postal system where CIDR is like zip codes. Just as zip codes help organize mail delivery to specific areas, CIDR blocks help organize network traffic to specific parts of your cloud infrastructure.

Example: A CIDR notation like 10.0.0.0/16 means you have addresses ranging from 10.0.0.0 to 10.0.255.255 – that's 65,536 IP addresses! A smaller block like 10.0.1.0/24 gives you 256 addresses.

Why it matters: CIDR helps you organize your network logically and ensures you have enough IP addresses for your needs without wasting them.

AZ (Availability Zone)

What it is: An isolated location within an AWS Region that contains data centers.

Real-life analogy: Think of AZs as separate power grids in a city. If one power grid fails due to a storm, the others can continue operating independently. Similarly, if one AZ has issues, your applications in other AZs can continue running.

Why it matters: Using multiple AZs protects your applications from outages in a single location – it's like not putting all your eggs in one basket.

Subnet

What it is: A subnet is a segment of a VPC's IP address range where you can place groups of resources.

Real-life analogy: If your VPC is a large office building, subnets are like different departments or floors. You might have the HR department on one floor, engineering on another, and marketing on a third.

Example: In our VPC with CIDR 10.0.0.0/16, we might create subnets like:

• Marketing department: 10.0.1.0/24 (256 addresses)

• Engineering department: 10.0.2.0/24 (256 addresses)

Why it matters: Subnets help organize your resources and apply different security rules to different groups of resources.

Public vs. Private Subnets

What they are: Public subnets can send and receive traffic directly from the internet, while private subnets cannot.

Real-life analogy: Public subnets are like the reception area of a building – accessible to visitors from outside. Private subnets are like secure back offices that only employees can access.

Why they matter: This separation helps maintain security. You keep customer-facing applications in public subnets while keeping sensitive data and backend systems in private subnets.

IGW (Internet Gateway)

What it is: An IGW allows resources in your VPC to connect to the internet.

Real-life analogy: An IGW is like the main entrance and exit of your building. It's the doorway through which people (or data) can come in from the public street (internet) or go out to it.

Why it matters: Without an IGW, resources in your VPC would be isolated from the internet – like a building with no doors to the outside world.

NAT (Network Address Translation) Gateway

What it is: A NAT Gateway allows resources in private subnets to access the internet while preventing the internet from initiating connections to those resources.

Real-life analogy: A NAT Gateway is like a security guard at a service entrance. Employees can go out to run errands (access the internet), but random people can't enter through this door (the internet can't initiate connections).

Example: Your database server in a private subnet needs to download updates. The NAT Gateway allows it to access the download server on the internet, but doesn't allow external users to connect directly to your database.

Why it matters: NAT Gateways provide a secure way for private resources to access the internet without exposing them to potential attacks.

Route Table

What it is: A route table contains a set of rules (routes) that determine where network traffic is directed.

Real-life analogy: Think of a route table as a GPS navigation system that tells data packets which way to go to reach their destination.

Example: Your route table might say "to reach the internet, go through the IGW" or "to reach this private subnet, go this way."

Why it matters: Route tables ensure your network traffic flows the right way, just like road signs ensure drivers take the correct routes.

Elastic IP

What it is: A static, public IPv4 address that you can allocate to your AWS account and associate with resources.

Real-life analogy: An Elastic IP is like a permanent phone number that stays the same even if you change phones. Even if your underlying AWS resources change, the Elastic IP remains constant.

Why it matters: When you need a fixed address for your resources (like a website domain pointing to your server), an Elastic IP ensures it doesn't change.

Putting It All Together

Imagine you're building a simple e-commerce website:

1. You create a VPC (your digital property) with a CIDR block of 10.0.0.0/16.

2. You create subnets in multiple AZs for redundancy:

   • Public subnets for your web servers

   • Private subnets for your database and application servers

3. You attach an IGW to your VPC so your web servers can serve content to your customers.

4. You set up a NAT Gateway so your private resources can download updates.

5. You configure route tables to direct traffic appropriately:

   • Public subnets route internet traffic through the IGW

   • Private subnets route internet traffic through the NAT Gateway

This setup ensures your website is both accessible to customers and secure from attacks.

Conclusion

Understanding AWS networking terms doesn't have to be complicated. By relating these concepts to everyday objects and situations, you can build a mental model that makes cloud networking more approachable. As you continue your AWS journey, you'll become more comfortable with these terms and how they work together to create secure, reliable network architectures.

Remember, even AWS experts started as beginners. Take it one acronym at a time, and soon you'll be speaking AWS networking fluently!

In today's fast-paced development environment, implementing a robust Continuous Integration and Continuous Deployment (CI/CD) pipeline is essential for delivering high-quality applications efficiently. This comprehensive guide will walk you through setting up a complete CI/CD pipeline for deploying Laravel applications on Amazon's Elastic Container Service (ECS).

TL;DR:

This guide walks you through setting up a CI/CD pipeline for deploying Laravel applications on AWS ECS using GitHub Actions. The pipeline automates code deployment by:

1. Pushing Code → Triggers GitHub Actions

2. Building a Docker Image → Pushed to Amazon ECR

3. Registering a New ECS Task → Updates the ECS service

4. Deploying via Load Balancer → Ensuring High Availability

It covers AWS setup, including IAM roles, Secrets Manager, ECR, ECS clusters, load balancers, and auto-scaling. Finally, it includes Dockerfile and Nginx configuration for Laravel deployment. 🚀

What is AWS ECS and ECR?

Before diving into how to use AWS ECS and ECR for deploying Laravel applications, it's essential to understand what these services are and how they work together in the AWS ecosystem.

Amazon Elastic Container Service (ECS)

Amazon ECS is a fully managed container orchestration service that helps you run and scale Docker containers on AWS. It allows you to easily deploy, manage, and scale containerized applications using a highly reliable and scalable infrastructure. ECS handles the scheduling of containers across a cluster of EC2 instances (or using Fargate for serverless containers) and automates many operational tasks, making it an ideal choice for managing microservices, batch jobs, and other containerized workloads.

ECS provides:

• Container orchestration: Manage and scale Docker containers in a cluster of EC2 instances.

• Task definitions: Define the application specifications such as Docker images, networking configurations, and resource requirements.

• Cluster management: ECS abstracts the underlying infrastructure, making it easy to manage containers and resources.

With ECS, you can easily automate deployment pipelines, ensure scalability, and manage the lifecycle of your application in a cloud-native way.

Amazon Elastic Container Registry (ECR)

Amazon ECR is a fully managed Docker container registry that allows you to store, manage, and deploy Docker container images. It integrates seamlessly with ECS, simplifying the process of storing and retrieving container images during deployment. ECR eliminates the need to manage your own container registry infrastructure and provides built-in security and scalability features, making it easier to manage containerized applications.

Key benefits of ECR include:

• Fully managed: ECR handles all aspects of container image storage, including scaling and security.

• Secure storage: Supports encryption of your images and integrates with AWS Identity and Access Management (IAM) for access control.

• Fast and reliable: Optimized for fast image pulls, ensuring that your deployment process is smooth and efficient.

• Integration with ECS and other AWS services: ECR is designed to work seamlessly with ECS, making it easier to deploy and manage your containers.

In short, ECR allows you to store Docker images securely and make them accessible for deployment, while ECS manages the deployment, scaling, and orchestration of these containerized applications.

By using ECS and ECR together, you can automate the entire lifecycle of containerized applications—from building Docker images to deploying them with a fully managed infrastructure, all within the AWS cloud.

Prerequisites

Before we begin, ensure you have the following:

• An AWS account

• A GitHub repository with your Laravel application

• Basic understanding of Docker, Laravel, and AWS services

• AWS CLI installed on your local machine

• GitHub account with access to GitHub Actions

Architecture Overview

Our CI/CD pipeline will follow this workflow:

1. Developer pushes code to the GitHub repository

2. GitHub Actions workflow is triggered

3. The workflow builds a Docker image for the Laravel application

4. The image is pushed to Amazon ECR

5. A new ECS task definition is registered with the updated image

6. The ECS service is updated to use the new task definition

7. The application is deployed through a load balancer for high availability

Setting Up AWS Infrastructure

Creating an IAM User with Required Permissions

First, let's create an IAM user with the necessary permissions for our CI/CD pipeline:

1. Navigate to the IAM console in your AWS account

2. Click on "Users" and then "Create user"

3. Enter a name for your user (e.g., "laravel-ecs-cicd-user")

4. Click "Next: Permissions"

5. Select "Attach existing policies directly"

6. Search and select the following policies:

   • AmazonEC2ContainerRegistryFullAccess

   • AmazonECS_FullAccess

   • AmazonECSTaskExecutionRolePolicy

   • SecretsManagerReadWrite

7. Click "Next: Tags" (add tags if needed)

8. Click "Next: Review"

9. Click “Create User” to initiate user creation.

10. Navigate back to the Users List and select the newly created user.

11. Open the Security Credentials tab.

12. Scroll down to the Access Keys section and click “Create Access Key.”

13. Copy and securely store the generated access keys, as they will not be displayed again.

Setting Up AWS Secrets Manager

Next, let's store our Laravel environment variables securely in AWS Secrets Manager:

1. Navigate to the AWS Secrets Manager console

2. Click "Store a new secret"

3. Select "Other type of secrets"

4. Enter your Laravel environment variables as key-value pairs JSON format (You can convert using ChatGPT):

    {
      "APP_NAME": "Laravel",
      "APP_ENV": "local",
      "APP_KEY": "base64:aWOTx31pPGbitApUzF6luBpFRtBxbLQHjardLfZKYTE=",
      "APP_DEBUG": "true",
      "APP_TIMEZONE": "UTC",
      "APP_URL": "http://localhost",
      "APP_LOCALE": "en",
      "APP_FALLBACK_LOCALE": "en",
      "APP_FAKER_LOCALE": "en_US",
      "APP_MAINTENANCE_DRIVER": "file",
      "BCRYPT_ROUNDS": "12",
      "LOG_CHANNEL": "stack",
      "LOG_STACK": "single",
      "LOG_DEPRECATIONS_CHANNEL": "null",
      "LOG_LEVEL": "debug",
      "DB_CONNECTION": "mysql",
      "DB_HOST": "localhost",
      "DB_PORT": "3306",
      "DB_DATABASE": "laravel",
      "DB_USERNAME": "root",
      "DB_PASSWORD": "",
      "SESSION_DRIVER": "database",
      "SESSION_LIFETIME": "120",
      "SESSION_ENCRYPT": "false",
      "SESSION_PATH": "/",
      "SESSION_DOMAIN": "null",
      "BROADCAST_CONNECTION": "log",
      "FILESYSTEM_DISK": "local",
      "QUEUE_CONNECTION": "database",
      "CACHE_STORE": "database",
      "CACHE_PREFIX": "",
      "MEMCACHED_HOST": "127.0.0.1",
      "REDIS_CLIENT": "phpredis",
      "REDIS_HOST": "127.0.0.1",
      "REDIS_PASSWORD": "null",
      "REDIS_PORT": "6379",
      "MAIL_MAILER": "log",
      "MAIL_HOST": "127.0.0.1",
      "MAIL_PORT": "2525",
      "MAIL_USERNAME": "null",
      "MAIL_PASSWORD": "null",
      "MAIL_ENCRYPTION": "null",
      "MAIL_FROM_ADDRESS": "hello@example.com",
      "MAIL_FROM_NAME": "Laravel",
      "AWS_ACCESS_KEY_ID": "",
      "AWS_SECRET_ACCESS_KEY": "",
      "AWS_DEFAULT_REGION": "us-east-1",
      "AWS_BUCKET": "",
      "AWS_USE_PATH_STYLE_ENDPOINT": "false",
      "VITE_APP_NAME": "Laravel"
    }
   

5. Click "Next"

6. Name your secret (e.g., "YourApp-ENV")

7. Add a description (optional)

8. Click "Next"

9. Leave rotation settings at defaults and click "Next"

10. Review and click "Store"

11. Note the ARN of your secret: arn:aws:secretsmanager:region:account-id:secret:YourApp-ENV-xxxxxx

Creating an ECR Repository

Now, let's create an ECR repository to store our Docker images:

1. Navigate to the Amazon ECR console

2. Click "Create repository"

3. Enter a name for your repository (e.g., "your-app-name")

4. Configure settings as needed (typically defaults are fine)

5. Click "Create repository"

6. Note the repository URI: account-id.dkr.ecr.region.amazonaws.com/your-app-name

Setting Up the ECS Cluster

Next, let's create our ECS cluster:

1. Navigate to the Amazon ECS console

2. Click "Create Cluster"

3. Select "Networking only" (we'll use Fargate)

4. Click "Next step"

5. Enter a cluster name (e.g., "your-app-cluster")

6. Leave other options at defaults

7. Click "Create"

Creating a Target Group and Load Balancer

Now, let's set up a load balancer to distribute traffic to our application:

1. Navigate to the EC2 console, then to "Target Groups"

2. Click "Create target group"

3. Choose "IP addresses" as target type (for Fargate)

4. Enter a name for your target group (e.g., "your-app-tg")

5. Set protocol to HTTP and port to 80

6. Select your VPC

7. Set health check path to /up (this matches our healthcheck in the task definition)

8. Configure advanced settings if needed

9. Click "Create"

10. Note the ARN of your target group

Next, create the Application Load Balancer:

1. Navigate to the EC2 console, then to "Load Balancers"

2. Click "Create Load Balancer"

3. Select "Application Load Balancer"

4. Enter a name for your load balancer (e.g., "your-app-alb")

5. Select "internet-facing"

6. Select your VPC and at least two subnets from different availability zones

7. Create or select a security group that allows HTTP/HTTPS traffic

8. Configure listeners:

   • Add a listener on port 80

   • Optionally add a listener on port 443 with SSL/TLS certificate

9. Configure routing to the target group you created earlier

10. Review and create the load balancer

11. Note the DNS name of your load balancer

Creating the ecsTaskExecutionRole

Before your ECS tasks can run properly, you need to create the ecsTaskExecutionRole that was referenced in the task definition:

1. Navigate to the IAM console in your AWS account

2. Click on "Roles" and then "Create role"

3. Select "AWS service" as the trusted entity type

4. Choose "Elastic Container Service" from the service list

5. Select "Elastic Container Service Task" as the use case

6. Click "Next: Permissions"

7. Search for and select the following policies:

   • AmazonECSTaskExecutionRolePolicy (this gives the role permission to pull images and send logs)

   • SecretsManagerReadWrite (if your tasks need to access Secrets Manager)

8. Click "Next: Tags" (add tags if needed)

9. Click "Next: Review"

10. Enter "ecsTaskExecutionRole" as the role name

11. Add a description such as "Allows ECS tasks to call AWS services on your behalf"

12. Click "Create role"

This role allows ECS to:

• Pull container images from ECR

• Send container logs to CloudWatch Logs

• Access secrets from AWS Secrets Manager (if needed by your application)

Make sure to note the ARN of this role as you'll need it for your task definition:

arn:aws:iam::your-account-id:role/ecsTaskExecutionRole

You'll need to update your task-definition.json file with this ARN in the "executionRoleArn" field.

Creating the ECS Service

Before running your GitHub Actions workflow, you need to create an ECS service:

1. Navigate to the ECS console, select your cluster

2. Click "Create service"

3. Select "FARGATE" as the launch type

4. Enter a service name (e.g., "your-app-service")

5. Set Number of tasks to 1 (or more for high availability)

6. Leave other options at defaults

7. Click "Next step"

8. Configure networking:

   • Select your VPC

   • Select at least two subnets in different availability zones

   • Select a security group that allows inbound traffic on port 80 from the load balancer

9. Click "Next step"

10. Configure load balancing:

    • Select "Application Load Balancer"

    • Select your load balancer

    • Add your container to the load balancer with port 80

    • Select your target group

11. Configure health check grace period if needed

12. Click "Next step"

13. Configure auto scaling if needed (optional)

14. Click "Next step"

15. Review and click "Create service"

Preparing Your Laravel Application

Dockerfile Setup

Create a Dockerfile in the root of your Laravel project:

ARG COMPOSER_VERSION=2.7
ARG PHP_VERSION=8.2
ARG NODE_VERSION=20
###########################################
# Prepare vendor images
###########################################
FROM composer:${COMPOSER_VERSION} AS vendor

# Node.js installation
FROM node:${NODE_VERSION}-alpine AS node

###########################################
# Build Backend and running web server
###########################################
# Use PHP 8.2 FPM Alpine as the base image
FROM php:${PHP_VERSION}-fpm-alpine AS server

ARG PROJECT_DIR=/var/www/html
ENV TZ=Australia/Sydney
# Set the working directory inside the container
WORKDIR $PROJECT_DIR

# Install system dependencies and PHP extensions
RUN apk add --no-cache nginx libpng libzip icu supervisor bash \
    && apk add --no-cache --virtual .build-deps \
    $PHPIZE_DEPS \
    libpng-dev \
    libzip-dev \
    icu-dev \
    && docker-php-ext-install opcache pdo pdo_mysql zip gd intl pcntl \
    && docker-php-ext-configure opcache --enable-opcache \
    && apk del .build-deps \
    && rm -rf /var/cache/apk/*

# Install and configure cron
RUN apk add --no-cache dcron \
    && mkdir -p /var/log/cron \
    && touch /var/log/cron/cron.log

RUN apk add --no-cache tzdata \
    && cp /usr/share/zoneinfo/$TZ /etc/localtime \
    && echo $TZ > /etc/timezone \
    && apk del tzdata

RUN apk add --no-cache curl

# Copy Composer from its image
COPY --chown=www-data:www-data --from=vendor /usr/bin/composer /usr/bin/composer
COPY --chown=www-data:www-data composer.json composer.lock ./

# copy .env file
COPY --chown=www-data:www-data .env .env

RUN composer install --no-dev --optimize-autoloader --no-scripts

# Copy Node.js from its image
COPY --from=node /usr/local /usr/local

# Install NPM dependencies
COPY --chown=www-data:www-data package.json package-lock.json ./
RUN npm cache clean --force \
    && npm install -g yarn --force \
    && yarn


# Copy application files
COPY --chown=www-data:www-data . $PROJECT_DIR

RUN yarn build

RUN mkdir -p storage/framework/sessions \
    storage/framework/views \
    storage/framework/cache \
    storage/framework/testing \
    storage/logs \
    bootstrap/cache \
    && chmod -R 775 storage bootstrap/cache

# Copy Nginx configuration file
COPY docker/nginx.conf /etc/nginx/nginx.conf

# Copy custom php.ini file to override PHP settings
COPY docker/php.ini /usr/local/etc/php/conf.d/php-custom.ini

# Copy entrypoint script
COPY docker/entrypoint.sh /usr/local/bin/entrypoint.sh
RUN chmod +x /usr/local/bin/entrypoint.sh

# Set entrypoint script to start both PHP-FPM and Nginx
ENTRYPOINT ["sh", "/usr/local/bin/entrypoint.sh"]

# Expose port 80
EXPOSE 80

Nginx Configuration

Create a directory named docker in your project root and add an nginx.conf file:

user nginx;  # Use 'nginx' user or the default user for the image if running unprivileged
worker_processes auto;

error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
}

daemon off;

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    sendfile on;
    keepalive_timeout 65;
    gzip on;
    gzip_disable "msie6";

    server {
        listen 80;  # Cloud Run default port

        server_name _;  # Accepts all hostnames

        root /var/www/html/public;  # Laravel's public directory

        index index.php index.html index.htm;

        location / {
            try_files $uri $uri/ /index.php$is_args$args;
        }

        location ~ \.php$ {
            include fastcgi_params;
            fastcgi_pass 127.0.0.1:9000;  # Assuming PHP-FPM is running locally in the container
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $fastcgi_path_info;
            fastcgi_split_path_info ^(.+?\.php)(/.+)$;
            # fastcgi_param HTTPS on;  # This is often needed for Laravel in production
        }

        location ~ /\.ht {
            deny all;
        }

        # Static file caching rules (optional, tweak for your needs)
        location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2|ttf|svg|eot)$ {
            expires 30d;
            add_header Cache-Control "public, no-transform";
        }
    }
}

PHP Configuration

Add a php.ini file in the docker directory:

; php.ini
memory_limit = 512M
upload_max_filesize = 10M

Entrypoint Script

Add an entrypoint.sh script in the docker directory:

#!/bin/sh
#set -e

# Function to run migrations with error handling
run_migrations() {
    echo "Running migrations"
    if php artisan migrate; then
        echo "Migrations completed successfully"
    else
        echo "Migration failed, attempting to cache resources anyway"
    fi
}

# Run migrations
run_migrations

exec "$@"

# Start PHP-FPM in the background
echo "Starting PHP-FPM..."
php-fpm --nodaemonize &
PHP_FPM_PID=$!

# Start Nginx in the background
echo "Starting Nginx..."
nginx &
NGINX_PID=$!

# Wait for all background processes
wait $NGINX_PID $PHP_FPM_PID

Creating the ECS Task Definition

Create a task-definition.json file in your project root:

{
    "family": "your-app-name",
    "networkMode": "awsvpc",
    "containerDefinitions": [
        {
            "name": "your-app-container",
            "image": "your-account-id.dkr.ecr.your-region.amazonaws.com/your-app-name:latest",
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "your-app-logs",
                    "awslogs-region": "your-region",
                    "awslogs-stream-prefix": "ecs"
                }
            },
            "healthCheck": {
                "command": [
                    "CMD-SHELL",
                    "curl -f http://localhost:80/up || exit 1"
                ],
                "interval": 30,
                "timeout": 5,
                "retries": 3,
                "startPeriod": 60
            }
        }
    ],
    "requiresCompatibilities": ["FARGATE"],
    "cpu": "256",
    "memory": "512",
    "executionRoleArn": "arn:aws:iam::your-account-id:role/ecsTaskExecutionRole"
}

Be sure to create a /up endpoint in your Laravel application that returns a 200 status code for health checks. This can be as simple as:

// In routes/web.php
Route::get('/up', function () {
    return response('OK', 200);
});

Setting Up GitHub Actions Workflow

Create a .github/workflows directory in your project root and add an ecs-deploy.yaml file:

name: Deploy Laravel to AWS ECS

on:
  push:
    branches:
      - main  # or your production branch

jobs:
  deploy:
    name: Deploy to AWS ECS
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v4

      - name: Set up AWS CLI
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_REGION }}

      - name: Check AWS CLI Configuration
        run: aws sts get-caller-identity

      - name: Flush DNS Cache
        run: sudo systemctl restart systemd-resolved || sudo systemd-resolve --flush-caches

      - name: Update Docker DNS settings
        run: |
            echo '{"dns":["8.8.8.8","8.8.4.4"]}' | sudo tee /etc/docker/daemon.json
            sudo systemctl restart docker

      - name: Retrieve Secrets from AWS Secrets Manager
        id: secrets
        run: |
          # Get secrets in JSON format
          SECRET_JSON=$(aws secretsmanager get-secret-value --secret-id ${{ secrets.AWS_SECRET_ARN }} --query SecretString --output text)

          # Convert JSON to KEY=VALUE format for .env file
          echo "$SECRET_JSON" | jq -r 'to_entries|map("\(.key)=\(.value|tostring)")|.[]' > .env

          # Verify the .env file (don't print sensitive info in logs)
          echo "Created .env file with the following keys:"
          grep -v "PASSWORD\|KEY" .env | cut -d= -f1

      - name: Login to Amazon ECR
        id: login-ecr
        run: |
          aws ecr get-login-password --region ${{ secrets.AWS_REGION }} | docker login --username AWS --password-stdin ${{ secrets.ECR_REPOSITORY }}

      - name: Build Docker Image
        run: |
          docker build -t ${{ secrets.ECR_REPOSITORY }}:latest .

      - name: Push Docker Image to ECR
        run: |
          docker push ${{ secrets.ECR_REPOSITORY }}:latest

      - name: Update ECS Task Definition
        id: task-def
        run: |
            # Use the task-definition.json file from the project root
            # Update the image in the task definition file
            jq '.containerDefinitions[0].image = "${{ secrets.ECR_REPOSITORY }}:latest"' task-definition.json > updated-task-definition.json

            # Register the new task definition
            NEW_REVISION=$(aws ecs register-task-definition --cli-input-json file://updated-task-definition.json)
            TASK_REVISION=$(echo $NEW_REVISION | jq -r '.taskDefinition.taskDefinitionArn')
            echo "TASK_REVISION=$TASK_REVISION" >> $GITHUB_ENV

      - name: Deploy New Task Definition
        run: |
            aws ecs update-service \
              --cluster ${{ secrets.ECS_CLUSTER }} \
              --service ${{ secrets.ECS_SERVICE }} \
              --task-definition $TASK_REVISION \
              --load-balancers "[{\"targetGroupArn\": \"${{ secrets.TARGET_GROUP_ARN }}\", \"containerName\": \"${{ secrets.CONTAINER_NAME }}\", \"containerPort\": 80}]"

Add the following secrets to your GitHub repository:

1. AWS_ACCESS_KEY_ID: Your IAM user access key

2. AWS_SECRET_ACCESS_KEY: Your IAM user secret key

3. AWS_REGION: Your AWS region (e.g., ap-southeast-2)

4. ECR_REPOSITORY: Your ECR repository URI

5. ECS_CLUSTER: Your ECS cluster name

6. ECS_SERVICE: Your ECS service name

7. AWS_SECRET_ARN: The ARN of your secret in AWS Secrets Manager

8. TARGET_GROUP_ARN: The ARN of your target group

9. CONTAINER_NAME: The name of your container (should match the name in task-definition.json)

Testing the CI/CD Pipeline

Now it's time to test your CI/CD pipeline:

1. Make a change to your Laravel application

2. Commit and push the changes to your main branch

3. Monitor the GitHub Actions workflow in the "Actions" tab of your repository

4. Once the workflow completes successfully, check your ECS service in the AWS console

5. Visit your load balancer's DNS name to see your application in action

Monitoring and Troubleshooting

To monitor your application and troubleshoot issues:

1. CloudWatch Logs: Check the logs from your ECS task

   • Navigate to CloudWatch in the AWS console

   • Go to "Log groups" and find your application's log group

2. ECS Task Status: Check the status of your ECS tasks

   • Navigate to ECS in the AWS console

   • Select your cluster and service

   • Check the "Tasks" tab to see running tasks and their status

3. Load Balancer Health: Check the health of your target group

   • Navigate to EC2 in the AWS console

   • Go to "Target Groups" and select your target group

   • Check the "Targets" tab to see the health status of your instances

4. GitHub Actions Workflow: Check the workflow logs for any issues

   • Navigate to the "Actions" tab in your GitHub repository

   • Select the latest workflow run

   • Check the logs for each step

Best Practices

1. Environment Variables: Keep sensitive information in AWS Secrets Manager

2. Versioning: Use Git tags or commit hashes for image versioning in production

3. Scaling: Configure auto-scaling for your ECS service based on CPU and memory usage

4. Monitoring: Set up CloudWatch alarms for important metrics

5. Security: Use IAM roles with least privilege principles

6. Backup: Regularly backup your database and critical data

7. Testing: Implement automated testing in your CI/CD pipeline

8. Rollback Plan: Have a plan for rolling back deployments if issues occur

Conclusion

You have now set up a complete CI/CD pipeline for your Laravel application using AWS ECS, ECR, and GitHub Actions. This pipeline automates the build, test, and deployment process, allowing you to deliver updates to your application with confidence.

By leveraging containerization with Docker and the scalability of AWS ECS, you've created a robust infrastructure that can handle your application's growth. The integration with AWS Secrets Manager ensures that your sensitive information is kept secure, while the Application Load Balancer provides high availability and distributes traffic efficiently.

Remember to regularly review and update your pipeline as your application evolves, and consider implementing additional features such as blue/green deployments or canary releases for even more reliability.

Happy coding!

Imagine you just moved into a smart home. You have sensors that tell you when doors are opened, how much electricity you're using, and if the temperature is too high. That's exactly what Amazon CloudWatch does for your applications in AWS – it's your all-in-one monitoring system for your cloud resources.

What is CloudWatch?

CloudWatch is like having a super-attentive building manager for your cloud applications. Just as your smart home system alerts you when something's wrong, CloudWatch keeps an eye on your AWS resources and applications, collecting data and sending alerts when needed.

Real-World Examples

Monitoring Like a Smart Fridge

Think about a modern refrigerator that tracks temperature and sends alerts to your phone if it gets too warm. CloudWatch does the same for your servers – if a server starts running too hot (high CPU usage) or is running out of space, it'll notify you before your ice cream melts (or before your application crashes).

Utility Bills Tracking

Just like you monitor your monthly water and electricity usage, CloudWatch tracks your AWS resource consumption. It helps you understand patterns – like knowing you use more electricity during dinner time, CloudWatch shows you when your application gets the most traffic.

Key Features

Metrics

Like checking your smart watch for steps, heart rate, and sleep quality, CloudWatch collects various metrics from your applications:

• CPU usage (how hard your server is working)

• Memory usage (how much information it's juggling)

• Network traffic (how many visitors you're getting)

Alarms

Similar to setting a burglar alarm at home, you can set CloudWatch alarms to alert you when something needs attention. For example, if your website starts responding slowly, you'll get notified immediately.

Logs

Just as your smart doorbell keeps a video history of visitors, CloudWatch keeps detailed logs of everything happening in your applications.

Pro Tip: Getting Laravel Logs from ECS to CloudWatch

Here's a handy trick for Laravel developers using Amazon ECS. To send your Laravel application logs to CloudWatch, you just need to make a simple configuration change. Here's how:

1. First, in your Laravel .env file, set:

LOG_CHANNEL=stderr

2. In your ECS task definition, ensure logging is configured:

{
    "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
            "awslogs-group": "/ecs/your-app-name",
            "awslogs-region": "your-region",
            "awslogs-stream-prefix": "ecs"
        }
    }
}

This setup makes Laravel write logs to stderr, which ECS automatically forwards to CloudWatch. It's like setting up your smart home devices to all report to one central app – everything's in one place!

Getting Started

Starting with CloudWatch is like setting up your first smart home device:

1. Log into your AWS Console

2. Navigate to CloudWatch

3. Start with basic metrics that AWS collects automatically

4. Gradually add more specific monitoring as you learn what's important for your application

Best Practices

1. Don't monitor everything at once. Start with the basics, like CPU and memory usage.

2. Set up meaningful alerts – like getting a notification when your website's error rate exceeds normal levels.

3. Keep your logs organized by using logical naming conventions.

CloudWatch might seem overwhelming at first, but think of it as your application's fitness tracker – it's there to help you keep everything healthy and running smoothly. Start small, learn from the data you collect, and gradually expand your monitoring as your needs grow.

Remember, just as you wouldn't want to run a smart home without any monitoring, you shouldn't run cloud applications without CloudWatch keeping an eye on things. It's your 24/7 digital superintendent, making sure everything runs smoothly while you focus on building great applications.

What is a VPC?

Imagine a VPC as your personal, secure digital neighborhood in the cloud. Just like a gated community has specific boundaries and rules, a VPC provides a logically isolated section of the AWS cloud where you can launch resources with complete control over network configuration.

Key VPC Fundamentals

1. VPC Structure

• A VPC exists within a specific AWS region

• Can contain multiple Availability Zones (AZs)

• Requires two primary components:

  1. Region selection

  2. IP address range (e.g., 10.1.0.0/16)

2. Subnets: The Organized Neighborhoods

Think of subnets like different neighborhoods within your digital community. Each subnet:

• Belongs to a specific VPC

• Exists in a single Availability Zone

• Has a unique IP range (subset of VPC's CIDR range)

• Example: 10.1.1.0/24 within a 10.1.0.0/16 VPC

Network Access and Connectivity

Internet Gateway

The internet gateway is like a controlled entrance/exit to your digital neighborhood. It:

• Provides internet access to your VPC

• Must be explicitly connected to be functional

• Acts as a bridge between your private network and the public internet

Virtual Private Gateway (VPG)

Consider this your secure, encrypted tunnel connecting your AWS network to another private network. It's like a private, guarded bridge between two exclusive communities.

Reserved IP Addresses: The Infrastructure Buffer

AWS reserves five IP addresses in each subnet for critical infrastructure:

• Used for routing

• DNS configuration

• Network management

• Reduces usable IP addresses in a subnet

Real-World Example

In a 10.0.0.0/22 VPC with 1,024 total IPs:

• Divided into four /24 subnets

• Each subnet has 256 IP addresses

• Only 251 IPs are actually available for use

Advanced Connectivity Options

AWS Direct Connect

Think of this as a dedicated, private fiber-optic cable directly connecting your on-premises data center to AWS. Benefits include:

• Secure physical connection

• Reduced network costs

• Consistent network performance

• Direct access to AWS services

Routing and Security

Route Tables

• Main route table: Default network traffic configuration

• Custom route tables: Granular control over network traffic

• Can define specific routing rules for different subnets

Network Access Control Lists (NACLs)

Imagine NACLs as subnet-level firewalls. Key characteristics:

• Stateless security mechanism

• Control inbound and outbound traffic

• Can allow or deny specific protocols, ports, and IP ranges

Best Practices

1. Use a /16 VPC range for flexibility

2. Create /24 subnets for manageable IP allocation

3. Implement custom route tables for granular control

4. Use NACLs for additional security layers

5. Carefully plan IP ranges and subnet divisions

Conclusion

A VPC is more than just a network—it's a sophisticated, secure, and flexible environment for hosting your cloud infrastructure. By understanding its components and leveraging its features, you can create robust, scalable, and secure cloud architectures.

What is an IP Address? Your Digital Home Address

Imagine the internet as a massive city, and each device is like a house. Just as every house has a unique address, every device connected to the internet has a unique identifier called an IP (Internet Protocol) address. This address helps data find its way from one device to another, just like a postal address helps mail reach the right destination.

Binary and Decimal: The Language of Computers

Understanding Binary

Binary is the computer's native language - a system using only two digits: 0 and 1. Think of it like a light switch that can only be on (1) or off (0). Every piece of digital information is essentially a series of these switches.

Decimal: Our Familiar Number System

Decimal is the number system we use daily, with 10 digits (0-9). When we talk about IP addresses, we typically use decimal notation.

Conversion Magic: Binary to Decimal

Easy Conversion Trick

Each binary digit (bit) represents a power of 2:

• Far right bit = 2^0 (1)

• Next bit = 2^1 (2)

• Next bit = 2^2 (4)

• And so on...

Example Conversion: Binary: 1010

• 1 × 2³ = 8

• 0 × 2² = 0

• 1 × 2¹ = 2

• 0 × 2⁰ = 0 Result: 8 + 0 + 2 + 0 = 10 (Decimal)

IP Address Structure

An IP address is typically 32 bits long (IPv4), divided into four octets:

• Each octet is 8 bits

• Range: 0-255 in decimal

• Example: 192.168.1.1

IP Address Classes

• Class A: 1.0.0.0 to 126.255.255.255

• Class B: 128.0.0.0 to 191.255.255.255

• Class C: 192.0.0.0 to 223.255.255.255

CIDR: Classless Inter-Domain Routing

CIDR is like a flexible zoning system for internet addresses. Instead of rigid address classes, it allows more precise network segmentation.

CIDR Notation

Format: IP Address/Prefix Length

• Example: 192.168.1.0/24

• "/24" means first 24 bits are network portion

• Meaning 24/8=3, first 3 portion is fixed, only last portion can be changed to 0-255

• 

Real-World Analogy

Think of CIDR like a neighborhood:

• IP Address = Specific house

• Prefix = Defining the entire neighborhood boundaries

Subnet Mask Conversion

• /24 = 255.255.255.0

• /16 = 255.255.0.0

• /8 = 255.0.0.0

Practical Applications

Network Segmentation

• Businesses use CIDR to:

  • Organize network infrastructure

  • Implement security boundaries

  • Manage IP address allocation efficiently

Cloud and Hosting

• Cloud providers use CIDR blocks to:

  • Allocate IP ranges to customers

  • Manage network isolation

  • Enable secure multi-tenant environments

Advanced Considerations

IPv6

• 128-bit address space

• Solves IP address exhaustion

• Notation: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

Subnetting Strategies

• Calculate usable host addresses

• Plan network growth

• Optimize network performance

Common Challenges and Solutions

IP Address Exhaustion

• NAT (Network Address Translation)

• IPv6 adoption

• Dynamic IP allocation

Security Implications

• Use of private IP ranges

• Implementing firewall rules

• Network segmentation

Pro Tips

• Always have a network addressing plan

• Use online CIDR calculators

• Understand your network's specific requirements

• Regularly audit and optimize IP allocations

Conclusion

Understanding IP addresses and CIDR blocks is like mastering the road map of the digital world. With practice, you'll navigate network configurations with confidence!

Imagine you're planning a big party, and instead of manually setting up each decoration, arranging chairs, and preparing food, you have a magical assistant who does everything exactly how you want with just one command. That's essentially what Terraform does for your digital infrastructure!

What is Terraform?

Terraform is like a universal remote control for your cloud resources. It's an Infrastructure as Code (IaC) tool that lets you describe and provision all your technology infrastructure using simple, human-readable configuration files. Instead of clicking through complex web consoles or running multiple manual commands, you write a script that defines exactly what you want - and Terraform makes it happen.

Real-Life Example: Building Your Digital Lego Set

Think of Terraform like a sophisticated Lego set for tech professionals. Just as you'd follow a blueprint to build a complex Lego structure, Terraform lets you create entire computer environments with a few lines of code.

In our specific example, we're using Terraform to effortlessly spin up an Nginx web server:

resource "docker_container" "nginx" {
  image = docker_image.nginx.image_id
  name  = "tutorial"

  ports {
    internal = 80
    external = 8000
  }
}

This tiny snippet does something that would typically require multiple manual steps: it pulls an Nginx image, creates a container, and maps network ports.

Why Should You Care?

1. Consistency is King

Imagine telling 10 people to make a sandwich. You'll get 10 different sandwiches. Terraform ensures every "sandwich" (server, network, database) is identical, every single time.

2. Version Control for Infrastructure

Just like Google Docs tracks changes, Terraform keeps a history of your infrastructure. Want to roll back to last week's setup? No problem!

3. Automation = Less Human Error

Humans make mistakes. Computers, when properly instructed, are precise. Terraform removes the "oops" factor from infrastructure management.

4. Multi-Cloud Flexibility

Whether you're using AWS, Azure, or Google Cloud, Terraform speaks their language. One tool, endless possibilities.

Getting Started is Easier Than You Think

Our example shows how simple it can be:

1. Install Terraform

2. Write a short configuration file

3. Run terraform apply

4. Boom! Your infrastructure is live

Where to start?

Just go there and choose your favourite cloud: https://developer.hashicorp.com/terraform/tutorials?product_intent=terraform

The Bottom Line

Terraform transforms complex, error-prone infrastructure management into a predictable, repeatable process. It's like having a super-smart assistant who never gets tired, never makes careless mistakes, and can rebuild your entire digital world with a single command.

Ready to level up your tech game? Terraform is your new best friend. 🚀🖥️

Ever wished your Mac could keep you connected to your spiritual routine without constant phone-checking? I've got a super simple hack that'll transform your menu bar into a prayer time tracker!

What You'll Need:

• A Mac

• Internet connection

• Google Calendar

• Notion Calendar

Step-by-Step Prayer Time Setup:

1. Find Your Prayer Web Calendar

   

   • Visit https://prayerwebcal.dsultan.com

   • Set up your specific location

   • Customize prayer time settings

2. Grab Your ICS URL

   • Scroll to the bottom of the page

   • Copy the unique URL, something like this:
     https://prayerwebcal.dsultan.com/ics/Dhaka_Dhaka_Bangladesh/cs=1:do=15:es=1:id=1:j=1:js=1:mv=1.0:nm=12:tz=Asia%2FDhaka:x=23.804:y=90.415

3. Add to Google Calendar

   

   • Open Google Calendar

   • Click the "+" icon next to "Other Calendars"

   • Select "From URL”

     

   • Paste your copied prayer time URL

   • Click "Add Calendar"

4. Install Notion Calendar

   • Download from https://www.notion.com/product/calendar

   • Install and log in with your Google account

     

   • From Settings > General > Set to run on startup

5. Configure Menu Bar

   

   • Open Notion Calendar settings

   • Click on "Menu Bar"

   • Enable Menu Bar

   • Adjust display preferences

And voilà! Your Mac's menu bar is now your personal prayer time companion. No more missed prayers or constant phone-checking – spiritual mindfulness, meet tech convenience! 🙌📱

Hey there, fellow developers! 👋 Remember your first Laravel deployment? Mine was a roller coaster of emotions that involved a lot of coffee, some hair-pulling moments, and finally, that sweet victory when everything worked. Today, I'm going to share how to deploy your Laravel application on cPanel without dealing with that pesky public folder configuration.

The Challenge

Picture this: It's 9 PM, and you've just finished your first Laravel project for a client. You're feeling pretty good about yourself until you realize – oh wait, the client has a shared hosting with cPanel, and you need to deploy it TODAY. The traditional Laravel structure wants you to point to the public folder, but your client's hosting doesn't support that. Don't panic! I've got you covered.

The Solution

We're going to use a clever workaround that keeps your application secure while working within cPanel's limitations. Here's how:

Step 1: Prepare Your Project

First, let's get your project ready for deployment:

1. Run composer install --optimize-autoloader --no-dev in your local environment

2. Run php artisan key:generate

3. Create a zip file of your entire Laravel project

4. Make sure your .env file is configured for production

Step 2: The Upload

1. Log into cPanel (take a deep breath, you got this!)

2. Navigate to File Manager

3. Go to public_html

4. Upload your zip file and extract it here

Step 3: The Magic Files

Now, here's where the magic happens. We need to create two special files in your root directory (public_html):

1. First, create a .htaccess file with these contents:

<IfModule mod_rewrite.c>
    <IfModule mod_negotiation.c>
        Options -MultiViews -Indexes
    </IfModule>
    RewriteEngine On
    php_value open_basedir "/var/www/html:/tmp"
    # Handle Authorization Header
    RewriteCond %{HTTP:Authorization} .
    RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
    # Redirect Trailing Slashes If Not A Folder...
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteCond %{REQUEST_URI} (.+)/$
    RewriteRule ^ %1 [L,R=301]
    # Handle Front Controller...
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^ index.php [L]
</IfModule>

2. Create an index.php file:

<?php
$uri = urldecode(
    parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH)
);

if ($uri !== '/' && file_exists(__DIR__.'/public'.$uri)) {
    return false;
}
require_once __DIR__.'/public/index.php';

Step 4: The Asset Update (Very Important!)

Here's a crucial step that many developers miss: You need to update all your asset URLs to include 'public/'. In your blade files, update your assets like this:

<!-- Before -->
<img src="/images/logo.png">
<link href="/css/app.css" rel="stylesheet">
<script src="/js/app.js"></script>

<!-- After -->
<img src="/public/images/logo.png">
<link href="/public/css/app.css" rel="stylesheet">
<script src="/public/js/app.js"></script>

Understanding the Magic

Let's break down what these files do:

• The .htaccess file acts as your traffic controller. It tells Apache how to handle incoming requests and properly route them through your Laravel application. It's like a security guard who knows exactly where to send your visitors.

• The index.php file is your bouncer. It catches all requests and forwards them to your actual Laravel application in the public folder. Think of it as a smart receptionist who knows how to handle every visitor.

Pro Tips from Someone Who Learned the Hard Way

1. Always keep a backup of your original files before making these changes

2. Test your asset paths thoroughly after deployment

3. Check your storage folder permissions (set to 755 for folders and 644 for files)

4. Don't forget to update your .env file with production settings

Troubleshooting Common Issues

• If your images aren't loading, double-check that you've added 'public/' to all asset URLs

• Getting a 500 error? Check your storage folder permissions

• Blank page? Enable error reporting in your .env file temporarily to see what's wrong

Conclusion

And there you have it! Your Laravel application is now running smoothly on cPanel without exposing your entire application structure. Remember, we all started somewhere, and these deployment challenges are just part of the journey to becoming a better developer.

Happy deploying! 🚀

P.S. Don't forget to celebrate with your favorite beverage when it all works – you've earned it!

In the world of continuous deployment, every second (and every penny) counts. Today, I'm going to show you a clever GitHub Actions hack that can save your team time and money while maintaining rock-solid deployment controls.

The Problem with Traditional Approval Workflows

Manual workflow approvals in GitHub Actions are great in theory, but they come with a hidden cost. While the workflow waits for human approval, you're burning through your Actions minutes - essentially paying for waiting time. Not very efficient, right?

Introducing the Issue-Based Approval System

What if we could create an approval workflow that:

• Costs nothing while waiting

• Provides clear tracking

• Offers granular access control

• Works seamlessly with your existing GitHub workflow

Let me introduce you to our ingenious solution: an Issue-Based Deployment Approval System.

✨ How It Works: The Science Behind the Magic

Workflow Trigger

1. When code is pushed to the dev branch or a pull request is merged

2. An automatically created GitHub issue prompts for deployment approval

Approval Mechanism

• Only specific team members or team roles can approve

• Approval is as simple as commenting "approve" or "LGTM" on the issue

• Built-in security checks verify the approver's identity

Deployment

• Once approved, the deployment runs immediately

• The approval issue is automatically closed

• A comment tracks who approved and what was deployed

A real world example

Wanna see if it’s true, check it here: https://github.com/sohag-pro/action-approval/issues/8

Action Implemented Repo: https://github.com/sohag-pro/action-approval

Please give a ⭐ if you find it helpful.

I'll share the two key workflow files that make this magic happen:

1. Issue Creation Workflow

.github/workflows/create-approval-issue.yml file

name: Create Approval Issue

on:
  push:
    branches:
      - dev
  pull_request:
    types: [closed]
    branches:
      - dev
permissions:
  issues: write
  contents: read

jobs:
  create-approval-issue:
    runs-on: ubuntu-latest
    if: github.event.pull_request.merged == true || github.event_name == 'push'
    steps:
      - name: Create Approval Issue
        uses: actions/github-script@v7
        with:
          script: |
            let commitSha = '';
            if (context.eventName === 'pull_request') {
              commitSha = context.payload.pull_request.merge_commit_sha;
            } else {
              commitSha = context.sha;
            }

            const shortSha = commitSha.substring(0, 7);

            const issueBody = `
            Please review and approve the deployment to staging.

            ### Approval Instructions
            - Only authorized team members can approve this deployment
            - Authorized approvers:
              - @sohag-pro
              - Members of teams: devops, senior-developers

            To approve, comment with one of these keywords: "approve", "LGTM"

            --- 
            Metadata (do not modify):
            \`\`\`json
            {
              "commit_sha": "${commitSha}",
              "branch": "dev",
              "triggered_by": "${context.eventName}"
            }
            \`\`\`
            `;

            const issue = await github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: `Deploy to Staging needs approval - ${shortSha}`,
              body: issueBody,
              labels: ['deployment-approval']
            });
            console.log(`Created issue #${issue.data.number}`);

🚀 Create Issue Workflow Explanation

Trigger:

1. push: When a new commit is pushed to the dev branch.

2. pull_request: When a pull request targeting the dev branch is merged.

Permissions:

• issues: write: To create an issue.

• contents: read: To read repository information.

Job: create-approval-issue

• Runs-on: ubuntu-latest.

Condition:

• The job runs if:

  • A pull request was merged (github.event.pull_request.merged == true).

  • Or the event is a push.

Steps:

1. Create Approval Issue:

   • Uses the actions/github-script action.

   • Extracts the commit SHA:

     • If the trigger is pull_request, it uses the merge_commit_sha of the pull request.

     • Otherwise, it uses the SHA of the latest pushed commit (context.sha).

   • Creates a short SHA (first 7 characters) for readability.

   • Constructs an issue body that includes:

     • Instructions for the approval process.

     • Metadata (commit SHA, branch, trigger source) in JSON format.

   • Creates a new issue with:

     • Title: Deploy to Staging needs approval - <short SHA>.

     • Body: Approval instructions and metadata.

     • Label: deployment-approval.

Purpose:

This workflow automates the creation of a tracking issue for deployment approval:

• Ensures all deployments to staging are documented and require explicit approval.

• Simplifies the process for authorized users to approve a deployment by commenting on the issue.

Key Highlights:

• Uses metadata for traceability (e.g., commit SHA, branch, and event source).

• Directly ties deployments to commits or merge events for better tracking.

• Encourages controlled deployments via a formal approval workflow.

2. Deployment Approval Workflow

.github/workflows/deploy-staging.yml

name: Deploy to Staging

on:
  issue_comment:
    types: [created]
    if: |
      contains(github.event.issue.title, 'Deploy to Staging needs approval')

permissions:
  issues: write
  contents: read
  pull-requests: read

jobs:
  process-approval:
    runs-on: ubuntu-latest

    if: |
      contains(github.event.issue.title, 'Deploy to Staging needs approval') &&
      (contains(github.event.comment.body, 'approve') || contains(github.event.comment.body, 'LGTM'))
    steps:
      - name: Check Approver
        id: check-approver
        uses: actions/github-script@v7
        with:
          script: |
            // Define allowed approvers
            const ALLOWED_APPROVERS = [
              'sohag-pro',
              'tech-lead',
              'devops-engineer'
            ];

            // Define allowed teams (team slugs)
            const ALLOWED_TEAMS = [
              'devops',
              'senior-developers'
            ];

            const commenter = context.payload.comment.user.login;
            console.log(`Comment by: ${commenter}`);

            // First check if user is directly in allowed list
            if (ALLOWED_APPROVERS.includes(commenter)) {
              console.log('Approver is in allowed users list');
              core.setOutput('status', 'authorized');
              return;
            }

            // Check if user is member of allowed teams
            let isTeamMember = false;
            for (const team of ALLOWED_TEAMS) {
              try {
                const { data: isMember } = await github.rest.teams.getMembershipForUserInOrg({
                  org: context.repo.owner,
                  team_slug: team,
                  username: commenter
                });

                if (isMember.state === 'active') {
                  console.log(`Approver is member of team: ${team}`);
                  isTeamMember = true;
                  break;
                }
              } catch (error) {
                console.log(`Error checking membership in team ${team}:`, error.message);
                continue;
              }
            }

            if (isTeamMember) {
              core.setOutput('status', 'authorized');
            } else {
              console.log('User not authorized to approve deployments');
              core.setOutput('status', 'unauthorized');
            }

      - name: Handle Unauthorized User
        if: steps.check-approver.outputs.status == 'unauthorized'
        uses: actions/github-script@v7
        with:
          script: |
            const approver = context.payload.comment.user.login;
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.issue.number,
              body: `❌ @${approver} is not authorized to approve deployments. Please wait for approval from an authorized team member.`
            });
            core.setFailed('Approval must come from an authorized user or team member');

      - name: Extract commit SHA
        id: extract-sha
        if: steps.check-approver.outputs.status == 'authorized'
        uses: actions/github-script@v7
        with:
          script: |
            const issueBody = context.payload.issue.body;
            const match = issueBody.match(/"commit_sha":\s*"([a-f0-9]+)"/);
            if (!match) {
              core.setFailed('Could not find commit SHA in issue body');
              return;
            }
            const commitSha = match[1];
            core.setOutput('commit_sha', commitSha);
            console.log(`Extracted commit SHA: ${commitSha}`);

      - uses: actions/checkout@v2
        if: steps.check-approver.outputs.status == 'authorized'
        with:
          ref: ${{ steps.extract-sha.outputs.commit_sha }}

      - name: Verify correct commit
        if: steps.check-approver.outputs.status == 'authorized'
        run: |
          current_sha=$(git rev-parse HEAD)
          expected_sha=${{ steps.extract-sha.outputs.commit_sha }}
          if [ "$current_sha" != "$expected_sha" ]; then
            echo "Error: Checked out SHA ($current_sha) does not match expected SHA ($expected_sha)"
            exit 1
          fi
          echo "Verified correct commit SHA: $current_sha"

      - name: Deploy to Staging
        if: steps.check-approver.outputs.status == 'authorized'
        run: |
          echo "Deploying commit ${{ steps.extract-sha.outputs.commit_sha }} to staging..."
          # Add your deployment commands here

      - name: Close Approval Issue
        if: steps.check-approver.outputs.status == 'authorized'
        uses: actions/github-script@v7
        with:
          script: |
            const issue_number = context.payload.issue.number;
            const deployedSha = '${{ steps.extract-sha.outputs.commit_sha }}';
            const approver = context.payload.comment.user.login;

            // Close the issue
            await github.rest.issues.update({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: issue_number,
              state: 'closed'
            });

            // Add completion comment
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: issue_number,
              body: `✅ Deployment to staging completed successfully!\n\nDeployed commit: ${deployedSha}\nBranch: dev\nApproved by: @${approver}`
            });

This GitHub Actions workflow automates the deployment of a commit to a staging environment based on approval comments in a GitHub issue. Here's a breakdown of its components:

🤖 Deploy workflow explanation

Trigger:

• Event: issue_comment is created.

• Condition: The issue title must contain the phrase "Deploy to Staging needs approval". The action runs only if this condition is met.

Permissions:

The workflow uses:

• issues: write (to interact with issues and comments),

• contents: read (to fetch repository data),

• pull-requests: read.

Jobs:

1. process-approval:

• Runs-on: ubuntu-latest.

• Condition: The issue must meet the following:

  • Title contains "Deploy to Staging needs approval".

  • The comment body includes the keywords approve or LGTM.

Steps:

1. Check Approver:

   • Uses the actions/github-script action.

   • Checks if the commenter:

     • Is in the list of allowed users (sohag-pro, tech-lead, devops-engineer), or

     • Belongs to one of the allowed teams (devops, senior-developers).

   • If authorized:

     • Sets the status to authorized.

   • If unauthorized:

     • Adds a comment rejecting the user's approval and fails the job.

2. Handle Unauthorized User:

   • Posts a rejection comment if the user isn't authorized.

3. Extract Commit SHA:

   • Extracts the commit_sha from the issue body using regex.

   • Fails if no valid SHA is found.

4. Checkout the Repository:

   • Checks out the repository using the extracted commit_sha.

5. Verify Correct Commit:

   • Ensures the checked-out commit matches the extracted SHA.

6. Deploy to Staging:

   • Executes deployment commands for the staging environment (placeholder for real deployment logic).

7. Close Approval Issue:

   • Closes the issue and adds a success comment with details:

     • Deployed commit SHA,

     • Branch name,

     • Approver's GitHub handle.

Purpose:

• Ensures controlled deployment to staging by verifying the approver's identity and explicitly approving the commit.

• Tracks the deployment process through issue comments and statuses.

Key Highlights:

• Implements a strict approval mechanism.

• Utilizes team-based and individual-based authorization.

• Automatically documents deployment activities in the related issue.

💡 Key Benefits

• Cost-Effective: Only pay for actual deployment time

• Secure: Strict access controls

• Transparent: Clear audit trail of who approved what

• Flexible: Easy to customize for your team's needs

Real-World Implementation Tips

1. Customize the ALLOWED_APPROVERS and ALLOWED_TEAMS

2. Add more detailed logging for compliance

3. Consider adding more approval keywords

4. Implement additional security checks as needed

Conclusion

This workflow demonstrates how a little creativity can solve real DevOps challenges. By thinking outside the traditional CI/CD box, we've created a solution that's not just clever, but genuinely useful.

Ready to Level Up Your Deployment Game? 🚀

Fork the workflows, adapt them to your needs, and watch your deployment process transform!

Would you like me to refine any part of the blog post or add more technical details?

1. Database & Eloquent Best Practices

1.1 Optimize Database Queries

// ❌ Bad: N+1 Query Problem
@foreach (Post::all() as $post)
    {{ $post->category->name }}
@endforeach

// ✅ Good: Eager Loading
$posts = Post::with('category')->get();
@foreach ($posts as $post)
    {{ $post->category->name }}
@endforeach

// ✅ Even Better: Use Laravel's Lazy Loading when needed
Model::withoutLazy()->get(); // Disable lazy loading in production

1.2 Use Query Builder for Complex Queries

// ✅ Good: Use Query Builder for complex queries
User::query()
    ->select(['name', 'email'])
    ->whereHas('posts', function ($query) {
        $query->where('published', true);
    })
    ->paginate();

2. Modern Controller Practices

2.1 Use Invokable Controllers for Single-Action Controllers

// ✅ Good: Single Action Controller
class ShowDashboardController extends Controller
{
    public function __invoke()
    {
        return view('dashboard', [
            'metrics' => $this->getMetrics(),
        ]);
    }
}

2.2 Use Form Requests for Validation

// ❌ Bad: Validation in Controller
public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'body' => 'required',
    ]);
}

// ✅ Good: Dedicated Form Request
class StoreArticleRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'title' => ['required', 'string', 'max:255'],
            'body' => ['required', 'string'],
            'category_id' => ['required', 'exists:categories,id'],
        ];
    }
}

public function store(StoreArticleRequest $request)
{
    $article = Article::create($request->validated());
}

3. Modern Architecture Patterns

3.1 Use Actions Classes for Business Logic

// ✅ Good: Single-Purpose Action Class
class PublishArticleAction
{
    public function execute(Article $article): void
    {
        $article->published_at = now();
        $article->status = ArticleStatus::Published;
        $article->save();

        event(new ArticlePublished($article));
    }
}

3.2 Use Data Transfer Objects (DTOs)

// ✅ Good: Use DTOs for complex data structures
class ArticleData
{
    public function __construct(
        public readonly string $title,
        public readonly string $content,
        public readonly ?Carbon $publishDate = null,
    ) {}

    public static function fromRequest(StoreArticleRequest $request): self
    {
        return new self(
            title: $request->validated('title'),
            content: $request->validated('content'),
            publishDate: $request->validated('publish_date'),
        );
    }
}

4. Modern View & Frontend Practices

4.1 Use Blade Components

// ✅ Good: Reusable Blade Components
// alert.blade.php
<x-alert type="{{ $type }}" :dismissible="$dismissible">
    {{ $slot }}
</x-alert>

// Usage
<x-alert type="success" :dismissible="true">
    Profile updated successfully!
</x-alert>

4.2 Use Laravel Vite for Asset Management

// ✅ Good: Modern Asset Management
// vite.config.js
import { defineConfig } from 'vite';
import laravel from 'laravel-vite-plugin';

export default defineConfig({
    plugins: [
        laravel({
            input: ['resources/css/app.css', 'resources/js/app.js'],
            refresh: true,
        }),
    ],
});

// In Blade
@vite(['resources/css/app.css', 'resources/js/app.js'])

5. Modern Testing Practices

5.1 Use Pest for Testing

// ✅ Good: Modern Testing with Pest
it('creates a new article', function () {
    $response = post('/articles', [
        'title' => 'My Article',
        'content' => 'Content here',
    ]);

    $response->assertCreated();
    expect(Article::count())->toBe(1);
});

5.2 Use Factories Effectively

// ✅ Good: Modern Factory Usage
class ArticleFactory extends Factory
{
    public function published(): self
    {
        return $this->state(fn (array $attributes) => [
            'published_at' => now(),
            'status' => ArticleStatus::Published,
        ]);
    }
}

// Usage
Article::factory()->published()->create();

6. API Development

6.1 Use API Resources

// ✅ Good: Use API Resources for Response Transformation
class ArticleResource extends JsonResource
{
    public function toArray($request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'content' => $this->when($request->user()?->isAdmin(), $this->content),
            'created_at' => $this->created_at->toISOString(),
        ];
    }
}

6.2 Use Sanctum for API Authentication

// ✅ Good: Modern API Authentication
Route::middleware(['auth:sanctum'])->group(function () {
    Route::apiResource('articles', ArticleController::class);
});

7. Performance Best Practices

7.1 Use Cache Effectively

// ✅ Good: Smart Caching
public function show(Article $article)
{
    return Cache::remember("articles.{$article->id}", now()->addHour(), fn () => 
        ArticleResource::make($article)
    );
}

7.2 Use Queue for Heavy Tasks

// ✅ Good: Queue Heavy Operations
class ProcessPodcast implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function handle(): void
    {
        // Heavy processing here
    }
}

8. Security Best Practices

8.1 Use Policy Classes

// ✅ Good: Use Policies for Authorization
class ArticlePolicy
{
    public function update(User $user, Article $article): bool
    {
        return $user->id === $article->user_id || $user->isAdmin();
    }
}

8.2 Secure Configuration

// ❌ Bad: Direct Environment Variable Usage
$apiKey = env('API_KEY');

// ✅ Good: Use Configuration Files
// config/services.php
'api' => [
    'key' => env('API_KEY'),
],

// Usage
$apiKey = config('services.api.key');

9. Code Organization

9.1 Use Laravel's Directory Structure

app/
├── Actions/         # Single-purpose action classes
├── Data/            # DTOs and other data objects
├── Events/          # Event classes
├── Listeners/       # Event listeners
├── Services/        # Complex business logic
├── Http/
│   ├── Controllers/
│   ├── Middleware/
│   └── Requests/    # Form requests
└── Models/          # Eloquent models

9.2 Use Service Providers for Bootstrap Code

// ✅ Good: Register Bindings in Service Provider
class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->singleton(PaymentGateway::class, StripeGateway::class);
    }
}

10. Development Workflow

10.1 Use Laravel Sail for Development

# ✅ Good: Use Laravel Sail for consistent development environment
sail up
sail artisan migrate
sail test

10.2 Use GitHub Actions for CI/CD

# ✅ Good: Automated Testing and Deployment
name: Laravel

on:
  push:
    branches: [ main ]

jobs:
  laravel-tests:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
    - name: Run Tests
      run: |
        composer install
        php artisan test

Laravel Naming Conventions

The following table outlines the standard naming conventions for Laravel applications in 2024:

Important Notes on Naming Conventions:

1. Consistency is Key

   • Stick to these conventions across your entire application

   • Use automated tools like PHP CS Fixer to enforce standards

2. Documentation

    // ✅ Good: Clear, consistent naming
    class PostController
    {
        public function show(Post $post)
        {
            return view('posts.show', compact('post'));
        }
    }
   

3. File Structure

    app/
    ├── Http/
    │   └── Controllers/
    │       └── PostController.php
    ├── Models/
    │   └── Post.php
    └── Views/
        └── posts/
            └── show-details.blade.php
   

4. Database Conventions

    // ✅ Good: Migration naming
    class CreatePostCommentsTable extends Migration
    {
        public function up()
        {
            Schema::create('post_comments', function (Blueprint $table) {
                $table->id();
                $table->foreignId('post_id')->constrained();
                $table->timestamps();
            });
        }
    }
   

5. Relationship Naming

    // ✅ Good: Clear relationship naming
    class Post extends Model
    {
        public function comments()
        {
            return $this->hasMany(Comment::class);
        }
   
        public function author()
        {
            return $this->belongsTo(User::class, 'user_id');
        }
    }
   

Following these naming conventions helps maintain consistency across your Laravel application and makes it easier for other developers to understand and work with your code. It also aligns with Laravel's built-in conventions, ensuring better integration with the framework's features and functionality.

Remember to:

• Use PHP 8.2+ features where appropriate

• Keep dependencies updated

• Follow PSR-12 coding standards

• Use static analysis tools like PHPStan

• Implement proper logging and monitoring

• Use Laravel Horizon for queue monitoring

• Implement proper error handling and logging

• Use Laravel Telescope for debugging in development

These practices reflect modern Laravel development as of 2024, incorporating new features and best practices from recent Laravel versions.

Ever walked into a room and immediately noticed something was off? Maybe it was a faint burning smell from the kitchen or the sound of a washing machine that didn't quite seem right. These warning signs in our daily lives are similar to what developers call "code smells" in programming—hints that something in our code needs attention.

What Are Code Smells?

Code smells are warning signs in our code that suggest deeper problems. They're not bugs—the code might work perfectly fine—but they indicate areas where your code could be cleaner, more efficient, or easier to maintain.

Think of it like a cluttered garage. Everything works and you can still park your car, but finding your tools takes longer than it should, and adding new items becomes increasingly difficult. That's exactly how code with "smells" feels to work with.

Common Code Smells in PHP and Laravel (And How to Fix Them)

1. The Long Method Smell

This is like trying to read an instruction manual with no chapters or sections—it's overwhelming and hard to follow.

Before (Smelly Code):

public function processOrder($orderId)
{
    $order = Order::find($orderId);

    // Validate order
    if (!$order) {
        throw new Exception('Order not found');
    }

    // Check inventory
    foreach ($order->items as $item) {
        $product = Product::find($item->product_id);
        if ($product->stock < $item->quantity) {
            throw new Exception('Insufficient stock');
        }
    }

    // Update inventory
    foreach ($order->items as $item) {
        $product = Product::find($item->product_id);
        $product->stock -= $item->quantity;
        $product->save();
    }

    // Process payment
    $payment = new Payment();
    $payment->amount = $order->total;
    $payment->order_id = $order->id;
    $payment->process();

    // Send email
    Mail::to($order->user->email)->send(new OrderConfirmation($order));

    // Update order status
    $order->status = 'processed';
    $order->save();
}

After (Clean Code):

public function processOrder($orderId)
{
    $order = $this->findOrder($orderId);
    $this->validateInventory($order);
    $this->updateInventory($order);
    $this->processPayment($order);
    $this->sendConfirmation($order);
    $this->updateOrderStatus($order);
}

private function findOrder($orderId)
{
    $order = Order::findOrFail($orderId);
    return $order;
}

private function validateInventory(Order $order)
{
    foreach ($order->items as $item) {
        if ($item->product->stock < $item->quantity) {
            throw new Exception('Insufficient stock');
        }
    }
}

// Additional methods...

2. The Duplicate Code Smell

Imagine having the same house key copied five times—if you need to change the lock, you'll have to replace all five keys. That's the problem with code duplication.

Before (Smelly Code):

public function calculateTotalPrice($items)
{
    $total = 0;
    foreach ($items as $item) {
        $price = $item->price;
        $tax = $price * 0.2;
        $shipping = $price > 100 ? 0 : 10;
        $total += $price + $tax + $shipping;
    }
    return $total;
}

public function calculateDiscountedPrice($items)
{
    $total = 0;
    foreach ($items as $item) {
        $price = $item->price;
        $tax = $price * 0.2;
        $shipping = $price > 100 ? 0 : 10;
        $discount = $price * 0.1;
        $total += $price + $tax + $shipping - $discount;
    }
    return $total;
}

After (Clean Code):

private function calculateBasePrice($item)
{
    $price = $item->price;
    $tax = $price * 0.2;
    $shipping = $price > 100 ? 0 : 10;
    return $price + $tax + $shipping;
}

public function calculateTotalPrice($items)
{
    return collect($items)->sum(function ($item) {
        return $this->calculateBasePrice($item);
    });
}

public function calculateDiscountedPrice($items)
{
    return collect($items)->sum(function ($item) {
        $basePrice = $this->calculateBasePrice($item);
        return $basePrice - ($item->price * 0.1);
    });
}

3. The God Object Smell

This is like having one kitchen drawer that holds everything from utensils to receipts to batteries. In Laravel, it often manifests as a model that knows too much and does too much.

Before (Smelly Code):

class User extends Model
{
    public function processOrder($items)
    {
        // Order processing logic
    }

    public function calculateTaxes()
    {
        // Tax calculation logic
    }

    public function sendWelcomeEmail()
    {
        // Email logic
    }

    public function generateInvoice()
    {
        // Invoice generation logic
    }

    public function updateShippingAddress($address)
    {
        // Address update logic
    }
}

After (Clean Code):

class User extends Model
{
    public function orders()
    {
        return $this->hasMany(Order::class);
    }
}

class OrderProcessor
{
    public function process(User $user, array $items)
    {
        // Order processing logic
    }
}

class TaxCalculator
{
    public function calculate(User $user)
    {
        // Tax calculation logic
    }
}

class UserMailer
{
    public function sendWelcome(User $user)
    {
        // Email logic
    }
}

Why It Matters

Addressing code smells isn't just about being pedantic—it has real, practical benefits:

1. Reduced Bug Risk: Cleaner code means fewer hiding places for bugs. When each piece of code has a single, clear responsibility, problems are easier to spot and fix.

2. Easier Maintenance: Think of clean code like a well-organized toolbox. When you need to fix something, you know exactly where to look.

3. Better Team Collaboration: New team members can understand and work with clean code more quickly, reducing onboarding time and friction.

4. Lower Technical Debt: By addressing code smells early, you prevent small issues from snowballing into major refactoring projects.

Laravel-Specific Tips

1. Use Laravel's built-in tools to fight code smells:

   • Leverage Service Providers for dependency injection

   • Use Form Requests for validation logic

   • Implement Jobs for complex processing

   • Utilize Events and Listeners for decoupling

2. Follow Laravel's conventions:

// Instead of this:
public function get_user_posts($user_id)

// Do this:
public function getUserPosts($userId)

Key Takeaways

1. Code smells are warning signs, not errors. They indicate areas where your code could be improved.

2. Regular refactoring is like regular house cleaning—it's easier to maintain cleanliness than to deal with accumulated mess.

3. Use Laravel's built-in features and conventions to write cleaner code from the start.

4. When in doubt, follow the Single Responsibility Principle: each class and method should do one thing and do it well.

Getting Started

Begin your code cleanup journey by:

1. Reviewing one piece of code at a time

2. Looking for the smells we've discussed

3. Making small, incremental improvements

4. Running tests after each change

5. Committing improvements regularly

Remember, perfect code doesn't exist, but better code always does. Start small, be consistent, and gradually build better coding habits. Your future self (and your teammates) will thank you!

Have you ever wished you could add your own special features to Laravel's built-in functions? That's exactly what Laravel macros let you do! Think of macros as custom add-ons that enhance Laravel's capabilities without messing with its core code. In this guide, we'll explore what macros are, how they work, and why they're so useful.

What Are Laravel Macros?

Imagine you have a Swiss Army knife. It comes with several useful tools like a knife, scissors, and screwdriver. Now, what if you could add your own custom tools to that Swiss Army knife without taking it apart? That's essentially what Laravel macros do for your code – they let you add new methods to existing Laravel classes.

Real-World Example

Let's say you frequently need to convert prices from one currency to another in your application. Instead of writing the same conversion code repeatedly, you could create a macro that adds a toCurrency method to Laravel's Collection class:

Collection::macro('toCurrency', function ($from = 'USD', $to = 'EUR') {
    return $this->map(function ($amount) use ($from, $to) {
        // Simple conversion logic for demonstration
        $rate = 0.85; // USD to EUR conversion rate
        return $amount * $rate;
    });
});

Now you can use it like this:

$prices = collect([10, 20, 30]);
$euroPrices = $prices->toCurrency('USD', 'EUR');
// Result: [8.5, 17, 25.5]

Creating Your First Macro

Setting up a macro is straightforward. Here's how to do it step by step:

1. Choose where to register your macro. The best place is usually in a service provider.

2. Create a new service provider if needed:

    php artisan make:provider MacroServiceProvider
   

3. Register your macro in the boot method:

namespace App\Providers;

use Illuminate\Support\Collection;
use Illuminate\Support\ServiceProvider;

class MacroServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Collection::macro('uppercase', function () {
            return $this->map(function ($value) {
                return strtoupper($value);
            });
        });
    }
}

4. Add your service provider to config/app.php:

'providers' => [
    // Other providers...
    App\Providers\MacroServiceProvider::class,
],

When to Use Macros

Macros are perfect for:

• Adding commonly used functionality across your application

• Extending Laravel's built-in classes with custom methods

• Keeping your code DRY (Don't Repeat Yourself)

• Creating domain-specific helper methods

The Importance of Macros

1. Code Reusability

Instead of copying and pasting the same code in multiple places, macros let you define the functionality once and use it everywhere. This makes your code more maintainable and reduces the chance of errors.

2. Clean Code

Macros help keep your code clean and organized. Instead of cluttering your controllers or models with utility methods, you can encapsulate common functionality in macros.

3. Consistent API

By using macros, you maintain a consistent API throughout your application. Your custom methods become part of Laravel's fluent interface, making your code more readable and intuitive.

4. Easy Testing

Macros can be easily tested in isolation, making your test suite more reliable and focused.

Best Practices

1. Name Clearly: Give your macros descriptive names that clearly indicate their purpose.

2. Keep it Simple: Each macro should do one thing and do it well.

3. Document Well: Add PHPDoc blocks to document your macros' parameters and return types.

4. Test Thoroughly: Write unit tests for your macros to ensure they work as expected.

Practical Example: Date Formatting Macro

Here's a practical example of a macro that adds a custom date formatting method to Laravel's Carbon date handling:

use Carbon\Carbon;

Carbon::macro('formatForHumans', function () {
    if ($this->isToday()) {
        return 'Today at ' . $this->format('H:i');
    }
    if ($this->isYesterday()) {
        return 'Yesterday at ' . $this->format('H:i');
    }
    return $this->format('M d, Y H:i');
});

Now you can use it anywhere in your application:

$date = Carbon::now();
echo $date->formatForHumans(); // "Today at 14:30"

Conclusion

Laravel macros are powerful tools that allow you to extend Laravel's functionality in a clean and maintainable way. They help you write more efficient code by:

• Reducing code duplication

• Providing a consistent API

• Making your code more readable and maintainable

• Allowing for easy testing

As you continue your Laravel journey, remember that macros are there to help you customize and extend the framework to better suit your needs. Start small with simple macros, and as you get more comfortable, you can create more complex ones to handle your specific use cases.

Remember: The best macro is one that solves a real problem in your application while making your code cleaner and more maintainable. Happy coding! 🚀

TL;DR: Want to set up a complete web server for your Laravel project without the headache? Just copy-paste a single command, answer a few simple questions, and you're done! It's like having a tech expert do all the heavy lifting for you.

Command: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/sohag-pro/SingleCommand/main/lamp.sh)"

Github: https://github.com/sohag-pro/SingleCommand

Why This Matters

Picture this: You've just finished building an awesome web application, and now you need to share it with the world. But wait – setting up a server feels like assembling furniture without instructions, in the dark, while wearing mittens. You need to install Apache, PHP, MySQL, Node.js, and configure them all to work together. It's enough to make anyone's head spin!

That's where this magical little script comes in. It's like having a tech-savvy friend who knows exactly what to do and handles all the complicated stuff for you. Instead of spending hours googling commands and troubleshooting errors, you can have your server ready in about the same time it takes to brew a cup of coffee.

What Does It Actually Do?

This script sets up what we call a "LAMP stack" (Linux, Apache, MySQL, PHP) along with some extra goodies that modern web development needs. Think of it as preparing a complete kitchen for a chef:

• Apache: Your restaurant's front door – it serves your website to visitors

• MySQL: Your pantry – stores all your application's data

• PHP: Your chef – processes all the requests and creates dynamic content

• Node.js: Your sous chef – helps with modern JavaScript tools

• Extra utilities: Various helpful tools like Git, Composer, and optionally Yarn and PM2

How to Use It

Prerequisites

Before you begin, make sure you have:

• A fresh Ubuntu 22.04 LTS server

• Admin (sudo) access

• An internet connection

• 5 minutes of free time

• Optional: A domain name if you want your site available at yourdomain.com

Step-by-Step Guide

1. Open your terminal and paste this command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/sohag-pro/SingleCommand/main/lamp.sh)"

2. The script will then ask you a few simple questions:

   • Which PHP version you want (7.4 through 8.4)

   • Your preferred MySQL username and password

   • Which version of Node.js you'd like

   • Whether you want extra tools like Yarn and PM2

   • Your GitHub repository URL

   • Your domain name

That's it! The script handles everything else automatically.

What Makes This Special?

1. Time-Saving: What usually takes hours of manual setup is reduced to minutes

2. Error-Proof: No more typos in commands or forgotten steps

3. Customizable: Choose your preferred versions of PHP and Node.js

4. Secure: Properly sets up permissions and security configurations

5. Complete: Includes everything you need for a modern Laravel application

Real-World Example

Imagine you're a developer who just finished a client's website. Instead of:

• Spending 2 hours installing and configuring packages

• Googling "how to set up Apache virtual hosts"

• Debugging MySQL permission issues

• Fighting with SSL certificate installation

You can just run one command, answer a few questions, and spend those saved hours actually working on your project (or maybe taking a well-deserved break!).

Best Practices and Tips

• Always run this on a fresh Ubuntu 22.04 installation

• Have your GitHub repository URL ready

• If you're using a domain name, set up your DNS A record before installing SSL

• Keep your MySQL credentials somewhere safe

• Make sure your repository has both .env.example and composer.json files

In Conclusion

Server setup doesn't have to be complicated or time-consuming. This script turns what used to be a daunting task into something as simple as ordering takeout. Whether you're a seasoned developer tired of repetitive setup tasks or a beginner intimidated by server configuration, this tool helps you get up and running quickly and reliably.

Remember: good tools should make your life easier, not harder. This script does exactly that – it handles the complex technical details so you can focus on what really matters: building great web applications.

Ready to try it out? Grab a coffee, run the command, and watch as your server sets itself up. Happy coding! 🚀

As a PHP developer, ensuring the performance and reliability of your applications is crucial, especially in high-traffic or resource-intensive environments. Performance monitoring allows you to identify bottlenecks, optimize resource usage, and provide a seamless user experience for your customers. In this beginner-friendly blog post, we'll explore the essentials of PHP performance monitoring, popular tools and techniques, and best practices for troubleshooting and optimizing your application's performance.

Understanding Performance Metrics

Performance monitoring revolves around various metrics that provide insights into the health and efficiency of your application. Some of the key metrics you'll want to track include:

1. Response Time: The time it takes for your application to respond to a user's request. This is a crucial metric that directly impacts user experience.

2. CPU Utilization: The percentage of available CPU resources being used by your application. High CPU usage can indicate inefficient code or resource-intensive processes.

3. Memory Usage: The amount of RAM being consumed by your application. Excessive memory usage can lead to performance degradation and potentially crash your application.

4. Database Queries: The number and execution time of database queries made by your application. Inefficient queries can significantly impact performance.

5. Error Rates: The frequency and types of errors occurring in your application, which can help identify problematic areas.

By monitoring these metrics, you can gain a comprehensive understanding of your application's performance and identify areas that need optimization.

Popular PHP Performance Monitoring Tools

To effectively monitor the performance of your PHP application, there are several popular tools and techniques you can leverage:

1. New Relic: New Relic is a widely used application performance monitoring (APM) tool that provides detailed insights into your application's performance, including transaction tracing, database monitoring, and error reporting.

2. Blackfire: Blackfire is a powerful profiling tool that helps you identify performance bottlenecks in your PHP code. It provides detailed profiling information, including CPU and memory usage, as well as recommendations for optimizations.

3. Xdebug: Xdebug is a PHP extension that enables advanced debugging and profiling capabilities. It can help you analyze code execution, identify slow-running functions, and pinpoint the root causes of performance issues.

4. PHP Caching: Implementing caching mechanisms, such as Memcached or Redis, can significantly improve the performance of your PHP application by reducing the load on your database and server resources.

5. PHP Profiling: Using built-in PHP profiling tools, such as Xdebug or the built-in profiler, can help you identify performance bottlenecks and optimize your code.

Let's dive into setting up and using some of these tools:

Setting up New Relic

1. Sign up for a New Relic account and install the New Relic PHP agent on your server.

2. Configure the agent by updating your php.ini file with the necessary settings.

3. Restart your web server, and you'll start seeing performance data in the New Relic dashboard.

4. Analyze the dashboard to identify slow transactions, database queries, and other performance issues.

Profiling with Blackfire

1. Install the Blackfire agent and probe on your server.

2. Configure the probe by updating your php.ini file with the necessary settings.

3. Run your application and use the Blackfire web interface or command-line tool to collect performance data.

4. Analyze the profiling report to identify performance bottlenecks and opportunities for optimization.

Debugging with Xdebug

1. Install the Xdebug extension on your server.

2. Configure Xdebug by updating your php.ini file with the necessary settings.

3. Use a PHP IDE, such as PHPStorm or Visual Studio Code, to enable Xdebug integration and start debugging your application.

4. Step through your code, inspect variables, and use Xdebug's profiling capabilities to identify performance issues.

Best Practices for PHP Performance Optimization

Alongside using performance monitoring tools, there are several best practices you can follow to improve and maintain the performance of your PHP application:

1. Optimize Database Queries: Ensure that your SQL queries are optimized, avoid N+1 query problems, and consider caching frequently accessed data.

2. Utilize Caching: Implement caching mechanisms, such as Memcached or Redis, to reduce the load on your database and server resources.

3. Optimize Code: Identify and address performance bottlenecks in your PHP code, such as inefficient algorithms, unnecessary function calls, or resource-intensive operations.

4. Leverage Asynchronous Processing: Use asynchronous processing, such as queues or background workers, to offload long-running or resource-intensive tasks.

5. Monitor and Troubleshoot: Continuously monitor your application's performance, analyze the data provided by your monitoring tools, and quickly address any emerging issues.

Conclusion and Further Resources

In this blog post, we've explored the essentials of PHP performance monitoring, including key performance metrics, popular tools and techniques, and best practices for optimization. By implementing a comprehensive performance monitoring strategy, you can ensure your PHP applications are efficient, reliable, and provide a seamless user experience.

For those interested in diving deeper into advanced PHP performance monitoring strategies, I recommend exploring resources such as the New Relic documentation, the Blackfire blog, and the Xdebug user guide. Additionally, staying up-to-date with the latest PHP performance-related articles and tutorials can help you continuously improve the performance of your applications.

Introduction

Imagine you're preparing breakfast every morning. Instead of taking out all the ingredients from different cabinets each time, you keep frequently used items like coffee, sugar, and bread on the counter for quick access. This is exactly how caching works in web applications – keeping frequently accessed data readily available to serve requests faster.

In Laravel applications, caching becomes crucial as your application grows and handles more users. Just as a busy café can't rely on a single coffee machine during rush hour, your application can't depend on a single cache store when scaling up. This is where distributed caching comes into play.

Understanding Basic Caching in Laravel

Before diving into distributed patterns, let's understand how basic caching works in Laravel:

// Storing data in cache
Cache::put('user_profile', $userProfile, now()->addHours(24));

// Retrieving data from cache
$userProfile = Cache::get('user_profile');

// Store if not exists
$value = Cache::remember('users', 3600, function () {
    return DB::table('users')->get();
});

Distributed Caching Patterns

1. Replication Pattern

Think of replication like having multiple copies of your favorite recipe book in different locations. If one gets damaged, you can still access the recipes from another copy.

Implementation Example:

// config/cache.php
'stores' => [
    'distributed' => [
        'driver' => 'redis',
        'connection' => 'cache',
        'replicas' => [
            ['host' => 'redis-1.example.com', 'port' => 6379],
            ['host' => 'redis-2.example.com', 'port' => 6379],
        ],
    ],
],

Usage:

class UserController extends Controller
{
    public function show($id)
    {
        return Cache::store('distributed')->remember(
            "user.{$id}",
            3600,
            function () use ($id) {
                return User::find($id);
            }
        );
    }
}

2. Sharding Pattern

Sharding is like organizing your wardrobe by categories – putting shirts in one drawer, pants in another. Each cache server handles specific types of data.

Implementation:

class ShardedCache
{
    protected $shards = [
        'users' => 'redis-1',
        'products' => 'redis-2',
        'orders' => 'redis-3'
    ];

    public function get($key)
    {
        $shard = $this->determineShardByKey($key);
        return Cache::store($shard)->get($key);
    }

    protected function determineShardByKey($key)
    {
        $prefix = explode('.', $key)[0];
        return $this->shards[$prefix] ?? 'default';
    }
}

3. Partitioning Pattern

Partitioning distributes data across servers based on a consistent hashing algorithm, like dividing students into different classrooms based on their last names.

class PartitionedCache
{
    protected $nodes = [
        'cache-1' => ['start' => 0, 'end' => 1000],
        'cache-2' => ['start' => 1001, 'end' => 2000],
        'cache-3' => ['start' => 2001, 'end' => 3000],
    ];

    public function set($key, $value, $ttl = 3600)
    {
        $node = $this->getNodeForKey($key);
        return Cache::store($node)->put($key, $value, $ttl);
    }

    protected function getNodeForKey($key)
    {
        $hash = crc32($key) % 3000;

        foreach ($this->nodes as $node => $range) {
            if ($hash >= $range['start'] && $hash <= $range['end']) {
                return $node;
            }
        }
    }
}

Best Practices

1. Cache Invalidation Strategy

// Use tags for easier cache management
Cache::tags(['users', "user.{$id}"])->put("user.{$id}", $userData, 3600);

// Invalidate all user-related caches
Cache::tags(['users'])->flush();

2. Handle Cache Failures Gracefully

public function getData($key)
{
    try {
        return Cache::get($key, function() {
            return $this->fetchFromDatabase();
        });
    } catch (Exception $e) {
        Log::error("Cache error: " . $e->getMessage());
        return $this->fetchFromDatabase();
    }
}

3. Implement Cache Warming

class WarmCache
{
    public function handle()
    {
        // Pre-cache frequently accessed data
        $popularProducts = Product::popular()->get();
        Cache::tags(['products'])->put('popular_products', $popularProducts, now()->addDay());
    }
}

Monitoring and Debugging

// Add cache hit/miss monitoring
Cache::extend('monitored', function ($app) {
    return Cache::repository(new MonitoredStore(
        new RedisStore($app['redis']),
        $app['events']
    ));
});

// Listen for cache events
Event::listen('cache.hit', function ($key) {
    Log::info("Cache hit for key: {$key}");
});

Conclusion

Distributed caching is essential for scaling Laravel applications effectively. By understanding and implementing these patterns correctly, you can significantly improve your application's performance and reliability. Remember:

• Use replication for high availability

• Implement sharding for better resource utilization

• Consider partitioning for balanced data distribution

• Always implement proper monitoring and fallback mechanisms

Further Learning

To deepen your understanding of distributed caching, explore these topics:

1. Redis Cluster Configuration and Management

2. Cache Coherency Protocols

3. Event-Driven Cache Invalidation

4. Cache-Aside vs. Write-Through Patterns

5. Laravel Horizon for Redis Queue Management

Remember that caching is an optimization technique that requires careful consideration of your specific use case. Start with simple implementations and gradually move to more complex patterns as your application's needs grow.

Introduction

Imagine walking to your kitchen every time you need a glass of water versus keeping a water bottle at your desk. That's essentially what caching is in programming - keeping frequently used data closer for quick access. In this guide, we'll explore caching in PHP, from basic concepts to advanced implementation with Laravel, making it relatable and practical for everyday development.

Why You Should Care

• Speed: Your applications can run up to 1000% faster with proper caching

• Cost Savings: Reduced server load means lower hosting costs

• User Experience: Faster response times = happier users

• Scalability: Handle more users without proportionally increasing resources

Think about it: Netflix doesn't re-encode a movie every time someone wants to watch it. They cache the encoded versions. Similarly, your PHP application shouldn't recalculate or refetch the same data repeatedly.

Basic Caching Concepts

1. Application-Level Caching

Think of this as your personal notepad where you jot down important information for quick reference.

// Without caching
function calculateComplexValue($input) {
    // Complex calculation that takes time
    sleep(2); // Simulating complex calculation
    return $input * 2;
}

// With caching
function calculateComplexValueCached($input) {
    static $cache = [];

    if (isset($cache[$input])) {
        return $cache[$input]; // Return cached result
    }

    // Calculate and cache result
    $cache[$input] = $input * 2;
    return $cache[$input];
}

Real-life example: Like keeping your frequently used cooking ingredients on the counter instead of the storage room.

2. Database Query Caching with Laravel

Similar to how a barista remembers regular customers' orders, Laravel can remember database query results.

// Without caching
$users = DB::table('users')
    ->where('active', 1)
    ->get();

// With caching
$users = Cache::remember('active_users', 3600, function () {
    return DB::table('users')
        ->where('active', 1)
        ->get();
});

Real-life example: A restaurant keeping its most-ordered dishes pre-prepared during rush hour.

3. View Caching

Think of this as taking a snapshot of your finished artwork instead of redrawing it every time.

// In your blade template
@cache('unique_key', 3600)
    @foreach($products as $product)
        <div class="product-card">
            {{ $product->name }}
        </div>
    @endforeach
@endcache

Advanced Caching Techniques

1. Redis Implementation

Redis is like having a super-fast assistant who remembers everything.

// Configure Redis in .env
REDIS_HOST=127.0.0.1
REDIS_PORT=6379

// Using Redis in Laravel
use Illuminate\Support\Facades\Redis;

Redis::set('user:1', json_encode($userData));
$userData = json_decode(Redis::get('user:1'));

2. Custom Cache Driver

Creating your own cache driver is like building a custom storage solution for specific needs.

namespace App\Cache;

use Illuminate\Contracts\Cache\Store;

class CustomCache implements Store
{
    public function get($key)
    {
        // Custom implementation
    }

    public function put($key, $value, $seconds)
    {
        // Custom implementation
    }

    // Other required methods...
}

3. Cache Tags

Like organizing your files with labels for easy access.

// Storing with tags
Cache::tags(['users', 'profiles'])->put('user:1', $userData, 3600);

// Retrieving tagged cache
$userData = Cache::tags(['users'])->get('user:1');

// Flush specific tags
Cache::tags(['users'])->flush();

Best Practices

1. Cache Invalidation Strategy

   • Set appropriate TTL (Time To Live)

   • Use cache tags for grouped invalidation

   • Implement versioning for cache keys

// Using cache versioning
$cacheKey = "users_list_v" . config('cache.version');

2. Security Considerations

   • Never cache sensitive data

   • Implement cache key prefixes

   • Use encryption when necessary

// Secure caching
Cache::tags(['secure'])->put(
    'user_data_' . hash('sha256', $userId),
    encrypt($userData),
    3600
);

3. Performance Monitoring

   • Monitor cache hit/miss ratios

   • Implement cache warming strategies

   • Use cache race condition prevention

// Atomic cache operations
Cache::lock('processing_data')->get(function () {
    // Process and cache data
});

Topics to Explore Further

1. Cache Backends

   • Memcached vs Redis

   • File-based caching

   • Database caching

2. Advanced Laravel Caching

   • Queue workers with cache

   • Broadcasting with cache

   • Rate limiting using cache

3. Distributed Caching

   • Cache synchronization

   • Cache replication

   • Cache clustering

Common Caching Patterns and Real-Life Analogies

1. Cache-Aside (Lazy Loading)

   • Like checking your pocket before going to the ATM

    function getData($key) {
        if (!Cache::has($key)) {
            Cache::put($key, fetchFromDatabase(), 3600);
        }
        return Cache::get($key);
    }

2. Write-Through

   • Like updating both your digital and paper calendar simultaneously

    function saveData($key, $value) {
        Database::save($value);
        Cache::put($key, $value, 3600);
    }

3. Write-Behind

   • Like collecting dishes in a bin and washing them all at once

    function saveData($key, $value) {
        Cache::put($key, $value, 3600);
        dispatch(new UpdateDatabaseJob($key, $value));
    }

Conclusion

Caching is not just a performance optimization technique; it's a fundamental concept that can make or break your application's success. Like a well-organized kitchen where everything has its place, proper caching ensures your PHP application runs smoothly and efficiently. Start with basic caching techniques and gradually move to more advanced patterns as your application grows.

Remember: The best caching strategy is the one that fits your specific needs. Don't overcomplicate it initially - start simple and optimize based on real usage patterns.

Further Reading:

• Laravel Official Documentation on Caching

• Redis Documentation

• PHP OpCache Configuration

• Memcached vs Redis Comparison

• Distributed Caching Architectures