DEV Community: Surender Gupta

🚀 Building a Production-Ready PHP Todo App with Clean Architecture & Security

Surender Gupta — Mon, 25 Aug 2025 12:46:05 +0000

As someone who has spent the last 7+ years working with PHP and modern backend architectures, I often see the same problem: most PHP tutorials and sample apps stop at CRUD.

That works for beginners — but when you’re building real-world software that needs to scale, handle authentication, and remain secure, you need more than just index.php and some SQL queries.

That’s why I decided to build a Modern PHP Todo App — not as a toy project, but as a blueprint for production-grade applications with advanced architecture, middleware-driven security, and testability at its core.

Why This Project Matters

Too many developers underestimate how powerful PHP can be when written with the right practices. This project demonstrates how you can use native PHP 8.3+ (no heavy frameworks) to design an application that’s:

Scalable → modular, layered, and testable
Secure → SQL injection–proof, JWT authentication, rate-limiting
Maintainable → clean separation of concerns with Controllers, Services, and Repositories
CI/CD Ready → with unit tests and dependency injection baked in

Core Features

Clean OOP architecture with Controllers, Services & Repositories
Custom Router for structured API endpoints
JWT Authentication Middleware (login & secure APIs)
Advanced Middlewares: - CORS handling - Rate Limiting - Validation - Logging
Security-first approach → PDO + parameter binding (SQLi safe)
Unit Tests with PHPUnit 12 → maintain reliability with every commit
Modular APIs for Todos & Users
Best Practices: Dependency Injection, Traits, Centralized Error Handling

Tech Stack

PHP 8.3+
PHPUnit 12 (unit & functional tests)
PDO (database access with parameter binding)
Middleware-driven security model
CI-friendly modular structure

Architecture at a Glance

Request 
   ↓
Router 
   ↓
Middleware (CORS | RateLimit | Auth | Logging)
   ↓
Controller (business entry point)
   ↓
Service (application logic)
   ↓
Repository (DB layer with PDO)
   ↓
Database

This layered structure ensures the app is easy to extend, debug, and secure — the same principles I follow when architecting production services for clients.

Repository

👉 Full source code here: GitHub – PHP Todo App
The repo is structured for readability, contributions, and future extensions (Docker, CI/CD pipelines, frontend integration).

What’s Next?

I see this as a foundation, not just a Todo app. Possible extensions include:
🚀 Docker & Kubernetes deployment
🔄 CI/CD pipelines with GitHub Actions or Jenkins
🌐 Frontend integration with React / Next.js
🔐 OAuth2 / Social Login
📊 Monitoring with Prometheus + Grafana
💡 Closing Thoughts

This project is a reminder that modern PHP is alive and thriving when combined with clean architecture and engineering discipline. Even a “simple Todo app” can become a playground for enterprise practices when built the right way.

If you’re a PHP developer (or exploring backend design principles), I’d love your feedback:
⭐ Star the repo
🛠️ Contribute ideas/features
💬 Share how you’d extend it
👉 GitHub: PHP Todo App

Happy Coding. Love Coding. Explore more.

Secure Your Kubernetes Cluster — A Hands-On Mini Project with RBAC, Secrets & Network Policies

Surender Gupta — Thu, 19 Jun 2025 12:31:07 +0000

Kubernetes is powerful — but with great power comes a giant security surface area.

In this hands-on mini project, I walk you through how to secure your Kubernetes cluster using built-in tools and real YAML examples:

✅ Role-Based Access Control (RBAC)

✅ Kubernetes Secrets (with proper injection into pods)

✅ Network Policies (to restrict lateral movement)

🧱 What You'll Learn

How to create least-privilege ServiceAccounts with RBAC
How to inject Secrets securely into your pods
How to use Network Policies to lock down internal pod communication
How to test and verify all of the above using kubectl, curl, and auth can-i

📖 Full Guide

📘 Read the complete breakdown with code and context on Medium:

👉 Medium Article

💻 GitHub Project Repository

All manifests and test YAMLs are available on GitHub for you to clone, run, and learn:

👉 GitHub Repo

☕ Why I Built This

Too many Kubernetes environments start secure... and then permissions spiral out of control. Secrets are exposed. Pods talk to everything. And suddenly, your cluster is wide open.

This project aims to make security practical, not theoretical. You don’t need fancy tools or expensive platforms — just the Kubernetes features you already have.

🚀 Next Steps

If this helped you:

Leave a ❤️ or 🦄 on Dev.to
Drop a comment with your thoughts or struggles
Share it with your DevOps or SRE team

Let's build secure by default. 🔐

Master GitOps with ArgoCD: Automate Your Kubernetes Deployments Like a Pro

Surender Gupta — Tue, 10 Jun 2025 18:15:35 +0000

Introduction: Why GitOps + ArgoCD Is the Future of Kubernetes Automation

Managing Kubernetes deployments manually or via scripts is error-prone, inconsistent, and hard to scale.

Enter GitOps — a methodology that uses Git as the single source of truth for your infrastructure and applications. And at the heart of GitOps for Kubernetes lies ArgoCD, the most popular continuous delivery tool purpose-built for GitOps.

In this practical guide, you’ll learn:

What GitOps is and how ArgoCD enables it
How to set up ArgoCD step-by-step
Best practices for automating and securing your Kubernetes workflows

By the end, you’ll be able to deploy apps to Kubernetes like a pro — with full auditability, rollback, and zero manual steps.

Section 1: What Is GitOps and Why It Works So Well with Kubernetes

GitOps isn’t just a buzzword — it’s a paradigm shift.

What is GitOps?

GitOps is the practice of:

Declaring infrastructure and app configs in Git
Automatically syncing Git changes to your cluster
Auditing every change via pull requests

It uses pull-based automation, which is more secure and auditable than traditional CI/CD.

Why GitOps + Kubernetes = ❤️

Kubernetes is declarative by design — so it’s a natural fit.
Git becomes your source of truth → ArgoCD syncs changes → Kubernetes executes them.

Benefits:

Instant rollback with git revert
Strong audit trail (Git history)
Zero-downtime deployments
No manual kubectl apply

Section 2: Getting Started with ArgoCD — Step-by-Step

Step 1: Install ArgoCD

kubectl create namespace argocd

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Access the UI:

kubectl port-forward svc/argocd-server -n argocd 8080:443

Default username: admin
Get password:

kubectl get secret argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 -d

Step 2: Create a Git Repo for Your Kubernetes Manifests

Structure:

.
├── dev/
│   ├── frontend.yaml
│   └── backend.yaml
├── staging/
└── production/

Store Kubernetes YAMLs, Kustomize bases, or Helm charts in Git.

Step 3: Connect Git Repo to ArgoCD

Create an Application resource:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/your-org/your-app
    targetRevision: main
    path: dev
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Apply it:

kubectl apply -f app.yaml

Now, ArgoCD auto-syncs your cluster to match your Git repo.

Section 3: ArgoCD Best Practices for Production

GitOps is powerful — but only if you follow strong operational patterns. Here’s how to productionize it:

1. Use RBAC and SSO

Integrate with GitHub, GitLab, or OIDC providers
Limit access by role and environment (e.g., dev vs prod)

2. Separate Repos by Environment

Avoid mixing prod and dev in the same repo
Use different ArgoCD Application objects per env

3. Use Health Checks and Sync Hooks

Customize sync steps with syncWave, preSync, postSync
Add health checks to catch failing states before rollback

4. Monitor and Alert with ArgoCD Metrics

Export ArgoCD Prometheus metrics
Use Grafana dashboards and alerting for failed syncs

5. Secure ArgoCD Itself

Run behind an ingress with HTTPS
Regularly rotate admin secrets
Avoid direct access from the internet unless via VPN or identity-aware proxy

Conclusion: Automate Everything with GitOps and ArgoCD
ArgoCD and GitOps are revolutionizing Kubernetes deployments.

No more fragile shell scripts. No more mystery configs.
Just reliable, trackable, and secure deployments, every time you git push.

If you’re managing Kubernetes at scale in 2025 and still deploying manually — you’re already behind.

Bonus Resources

🙏 Support My Work

If this guide helped you understand GitOps or ArgoCD a little better, consider supporting me with a coffee.

It helps me keep writing honest, practical DevOps content that simplifies complex tools for engineers like you.

👉 buymeacoffee.com/surendergupta

How to Download Any YouTube Video Using One Terminal Command (No Ads, No Bloat)

Surender Gupta — Tue, 10 Jun 2025 15:18:51 +0000

Introduction

Tired of dodgy online downloaders filled with popups and trackers? Let’s go clean, fast, and powerful — using the terminal. Whether you’re a content creator, researcher, or just offline-first, yt-dlp is your best tool.

Step 1: Install yt-dlp

If you’re on Windows, use the built-in package manager:

winget install yt-dlp

That’s it. If you don’t have winget, ensure you’re on Windows 10+ with the latest App Installer.

Step 2: Download a YouTube Video

Just grab the link of the video you want and paste it into this command:

yt-dlp https://www.youtube.com/watch?v=dQw4w9WgXcQ

This downloads the highest quality version by default.

Step 3: Advanced Usage

Audio only:

yt-dlp -f bestaudio URL

Playlist download:

yt-dlp -i --yes-playlist URL

Custom output name:

yt-dlp -o "%(title)s.%(ext)s" URL

Why Use yt-dlp Over Other Tools?

Open-source and regularly updated
Handles age-restricted & geo-blocked videos better than youtube-dl
No ads or shady redirects
Batch download support

Final Thoughts

With one command, you unlock full control over video downloads. Whether it’s for personal viewing, remixing content, or offline archiving, yt-dlp is the fastest and safest method available.

💬 Have questions or favorite use cases? Drop them in the comments!

💻 Building DApps with PHP and Web3: A Full-Stack Dev’s Guide to Smart Contract Integration

Surender Gupta — Sat, 07 Jun 2025 10:05:21 +0000

Excerpt:
Most Web3 devs stick to Node.js or use front-end only DApps. But I’ve found huge success combining Web3.js with Laravel (PHP) to create secure, full-featured decentralized apps.

Here’s my stack:

PHP (Laravel) as backend
Web3.js frontend
Smart contract interaction (read/write)
MetaMask or WalletConnect for auth
JSON-RPC or Infura for blockchain communication

This setup is perfect for:

✅ Startup MVPs
✅ NFT portals
✅ DeFi dashboards
✅ Token analytics tools

Want me to build yours?
🎯 Check out my Fiverr gig: https://www.fiverr.com/s/DBXAxDV

Let’s push Web3 development forward — one secure backend at a time 💪

🚀 Full-Stack PHP, MERN, and DApp Development – Let’s Build Something Awesome

Surender Gupta — Tue, 03 Jun 2025 10:27:41 +0000

Hey devs and founders!

I’m Surender Gupta, a full-stack engineer with 7+ years of experience across modern and decentralized web stacks.

💡 Tech Stack Highlights:

Backend: PHP (Laravel, CodeIgniter), Node.js (Express)
Frontend: React.js, Vue.js, Tailwind, MUI
Blockchain: Solidity, Web3, DApp integration
DevOps: Docker, Jenkins, Kubernetes, AWS
DBs: MySQL, MongoDB, PostgreSQL

Let’s build something amazing together.

🔗 Connect with me:

LinkedIn

GitHub
Fiverr
Freelancer
Upwork
Facebook

💬 DM me if you need a reliable tech partner to launch your idea! 🚀

How I Built a DApp Using PHP, Solidity, and JavaScript on Binance Smart Chain (With Dockerized Deployment)

Surender Gupta — Sat, 31 May 2025 16:38:33 +0000

🚀 Project Overview

I've recently built a full-stack Decentralized Application (DApp) using:

🐘 PHP for backend logic and APIs
💻 JavaScript for the frontend UI
🧠 Solidity for smart contracts
🔗 Binance Smart Chain as the blockchain layer
🐳 Docker & Docker Compose for deployment

This project was an exciting mix of traditional backend skills and modern Web3 architecture. Here's how I did it 👇

🧱 Tech Stack

Layer	Technology
Smart Contracts	Solidity on BSC
Backend	PHP (vanilla or Laravel)
Frontend	JavaScript (with Web3.js)
Containerization	Docker & Docker Compose

🔐 Smart Contracts on Binance Smart Chain

The smart contracts were developed in Solidity, tested with Hardhat, and deployed to the Binance Smart Chain Testnet.

Example contract snippet:

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

interface IBEP20 {
  function totalSupply() external view returns (uint256);

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getOwner() external view returns (address);

  function balanceOf(address account) external view returns (uint256);

  function transfer(address recipient, uint256 amount) external returns (bool);

  function allowance(address _owner, address spender) external view returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

  event Transfer(address indexed from, address indexed to, uint256 value);

  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract FIZZYFY  {
    using SafeMath for uint256; 
    IBEP20 public busd;
    address public contractOwner;
    modifier onlyContractOwner() { 
        require(msg.sender == contractOwner, "onlyOwner"); 
        _; 
    }
    uint256 private constant baseDivider = 10000;
    uint256 private constant feePercents = 200; 
    uint256 private constant minDeposit = 50e18;
    uint256 private constant maxDeposit = 2000e18;
    uint256 private constant freezeIncomePercents = 3000;
    uint256 private constant timeStep = 1 days;
    uint256 private constant dayPerCycle = 10 days; 
    uint256 private constant dayRewardPercents = 160;
    uint256 private constant maxAddFreeze = 45 days;
    uint256 private constant referDepth = 20;

    uint256 private constant directPercents = 500;
    uint256[4] private level4Percents = [100, 200, 300, 100];
    uint256[15] private level5Percents = [200, 100, 100, 100, 100, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50];

    uint256 private constant luckPoolPercents = 50;
    uint256 private constant starPoolPercents = 30;
    uint256 private constant topPoolPercents = 20;

    uint256[5] private balDown = [10e10, 30e10, 100e10, 500e10, 1000e10];
    uint256[5] private balDownRate = [1000, 1500, 2000, 5000, 6000]; 
    uint256[5] private balRecover = [15e18, 50e10, 150e10, 500e10, 1000e10];
    mapping(uint256=>bool) public balStatus; // bal=>status

    address[2] public feeReceivers;

    address public defaultRefer;
    uint256 public startTime;
    uint256 public lastDistribute;
    uint256 public totalUser; 
    uint256 public luckPool;
    uint256 public starPool;
    uint256 public topPool;

    mapping(uint256=>address[]) public dayLuckUsers;
    mapping(uint256=>uint256[]) public dayLuckUsersDeposit;
    mapping(uint256=>address[3]) public dayTopUsers;

    address[] public level4Users;

    struct OrderInfo {
        uint256 amount; 
        uint256 start;
        uint256 unfreeze; 
        bool isUnfreezed;
    }

    mapping(address => OrderInfo[]) public orderInfos;

    address[] public depositors;

    struct UserInfo {
        address referrer;
        uint256 start;
        uint256 level;
        uint256 maxDeposit;
        uint256 totalDeposit;
        uint256 teamNum;
        uint256 maxDirectDeposit;
        uint256 teamTotalDeposit;
        uint256 totalFreezed;
        uint256 totalRevenue;
    }

    mapping(address=>UserInfo) public userInfo;
    mapping(uint256 => mapping(address => uint256)) public userLayer1DayDeposit;
    mapping(address => mapping(uint256 => address[])) public teamUsers;

    struct RewardInfo{
        uint256 capitals;
        uint256 statics;
        uint256 directs;
        uint256 level4Freezed;
        uint256 level4Released;
        uint256 level5Left;
        uint256 level5Freezed;
        uint256 level5Released;
        uint256 star;
        uint256 luck;
        uint256 top;
        uint256 split;
        uint256 splitDebt;
    }

    mapping(address=>RewardInfo) public rewardInfo;

    bool public isFreezeReward;

    event Register(address user, address referral);
    event Deposit(address user, uint256 amount);
    event DepositBySplit(address user, uint256 amount);
    event TransferBySplit(address user, address receiver, uint256 amount);
    event Withdraw(address user, uint256 withdrawable);

    constructor(IBEP20 _busdAddr, address _defaultRefer, address[2] memory _feeReceivers) public {
        busd = _busdAddr;
        feeReceivers = _feeReceivers;
        startTime = block.timestamp;
        lastDistribute = block.timestamp;
        defaultRefer = _defaultRefer;
    }

    function register(address _referral) external {
        require(userInfo[_referral].totalDeposit > 0 || _referral == defaultRefer, "invalid refer");
        UserInfo storage user = userInfo[msg.sender];
        require(user.referrer == address(0), "referrer bonded");
        user.referrer = _referral;
        user.start = block.timestamp;
        _updateTeamNum(msg.sender);
        totalUser = totalUser.add(1);
        emit Register(msg.sender, _referral);
    }

    function deposit(uint256 _amount) external {        
        busd.transferFrom(msg.sender, address(this), _amount);
        _deposit(msg.sender, _amount);
        emit Deposit(msg.sender, _amount);
    }

    function depositBySplit(uint256 _amount) external {
        require(_amount >= minDeposit && _amount.mod(minDeposit) == 0, "amount err");
        require(userInfo[msg.sender].totalDeposit == 0, "actived");
        uint256 splitLeft = getCurSplit(msg.sender);
        require(splitLeft >= _amount, "insufficient split");
        rewardInfo[msg.sender].splitDebt = rewardInfo[msg.sender].splitDebt.add(_amount);
        _deposit(msg.sender, _amount);
        emit DepositBySplit(msg.sender, _amount);
    }

    function transferBySplit(address _receiver, uint256 _amount) external {
        require(_amount >= minDeposit && _amount.mod(minDeposit) == 0, "amount err");
        uint256 splitLeft = getCurSplit(msg.sender);
        require(splitLeft >= _amount, "insufficient income");
        rewardInfo[msg.sender].splitDebt = rewardInfo[msg.sender].splitDebt.add(_amount);
        rewardInfo[_receiver].split = rewardInfo[_receiver].split.add(_amount);
        emit TransferBySplit(msg.sender, _receiver, _amount);
    }

    function distributePoolRewards() public {
        if(block.timestamp > lastDistribute.add(timeStep)){
            uint256 dayNow = getCurDay();
            _distributeStarPool();

            _distributeLuckPool(dayNow);

            _distributeTopPool(dayNow);
            lastDistribute = block.timestamp;
        }
    }

    function withdraw() external {
        distributePoolRewards();
        (uint256 staticReward, uint256 staticSplit) = _calCurStaticRewards(msg.sender);
        uint256 splitAmt = staticSplit;
        uint256 withdrawable = staticReward;

        (uint256 dynamicReward, uint256 dynamicSplit) = _calCurDynamicRewards(msg.sender);
        withdrawable = withdrawable.add(dynamicReward);
        splitAmt = splitAmt.add(dynamicSplit);

        RewardInfo storage userRewards = rewardInfo[msg.sender];
        userRewards.split = userRewards.split.add(splitAmt);

        userRewards.statics = 0;

        userRewards.directs = 0;
        userRewards.level4Released = 0;
        userRewards.level5Released = 0;

        userRewards.luck = 0;
        userRewards.star = 0;
        userRewards.top = 0;

        withdrawable = withdrawable.add(userRewards.capitals);
        userRewards.capitals = 0;

        busd.transfer(msg.sender, withdrawable);
        uint256 bal = busd.balanceOf(address(this));
        _setFreezeReward(bal);

        emit Withdraw(msg.sender, withdrawable);
    }

    function getCurDay() public view returns(uint256) {
        return (block.timestamp.sub(startTime)).div(timeStep);
    }

    function getDayLuckLength(uint256 _day) external view returns(uint256) {
        return dayLuckUsers[_day].length;
    }

    function getTeamUsersLength(address _user, uint256 _layer) external view returns(uint256) {
        return teamUsers[_user][_layer].length;
    }

    function getOrderLength(address _user) external view returns(uint256) {
        return orderInfos[_user].length;
    }

    function getDepositorsLength() external view returns(uint256) {
        return depositors.length;
    }

    function getMaxFreezing(address _user) public view returns(uint256) {
        uint256 maxFreezing;
        for(uint256 i = orderInfos[_user].length; i > 0; i--){
            OrderInfo storage order = orderInfos[_user][i - 1];
            if(order.unfreeze > block.timestamp){
                if(order.amount > maxFreezing){
                    maxFreezing = order.amount;
                }
            }else{
                break;
            }
        }
        return maxFreezing;
    }

    function getTeamDeposit(address _user) public view returns(uint256, uint256, uint256){
        uint256 totalTeam;
        uint256 maxTeam;
        uint256 otherTeam;
        for(uint256 i = 0; i < teamUsers[_user][0].length; i++){
            uint256 userTotalTeam = userInfo[teamUsers[_user][0][i]].teamTotalDeposit.add(userInfo[teamUsers[_user][0][i]].totalDeposit);
            totalTeam = totalTeam.add(userTotalTeam);
            if(userTotalTeam > maxTeam){
                maxTeam = userTotalTeam;
            }
        }
        otherTeam = totalTeam.sub(maxTeam);
        return(maxTeam, otherTeam, totalTeam);
    }

    function getCurSplit(address _user) public view returns(uint256){
        (, uint256 staticSplit) = _calCurStaticRewards(_user);
        (, uint256 dynamicSplit) = _calCurDynamicRewards(_user);
        return rewardInfo[_user].split.add(staticSplit).add(dynamicSplit).sub(rewardInfo[_user].splitDebt);
    }

    function _calCurStaticRewards(address _user) private view returns(uint256, uint256) {
        RewardInfo storage userRewards = rewardInfo[_user];
        uint256 totalRewards = userRewards.statics;
        uint256 splitAmt = totalRewards.mul(freezeIncomePercents).div(baseDivider);
        uint256 withdrawable = totalRewards.sub(splitAmt);
        return(withdrawable, splitAmt);
    }

    function _calCurDynamicRewards(address _user) private view returns(uint256, uint256) {
        RewardInfo storage userRewards = rewardInfo[_user];
        uint256 totalRewards = userRewards.directs.add(userRewards.level4Released).add(userRewards.level5Released);
        totalRewards = totalRewards.add(userRewards.luck.add(userRewards.star).add(userRewards.top));
        uint256 splitAmt = totalRewards.mul(freezeIncomePercents).div(baseDivider);
        uint256 withdrawable = totalRewards.sub(splitAmt);
        return(withdrawable, splitAmt);
    }

    function _updateTeamNum(address _user) private {
        UserInfo storage user = userInfo[_user];
        address upline = user.referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                userInfo[upline].teamNum = userInfo[upline].teamNum.add(1);
                teamUsers[upline][i].push(_user);
                _updateLevel(upline);
                if(upline == defaultRefer) break;
                upline = userInfo[upline].referrer;
            }else{
                break;
            }
        }
    }

    function _updateTopUser(address _user, uint256 _amount, uint256 _dayNow) private {
        userLayer1DayDeposit[_dayNow][_user] = userLayer1DayDeposit[_dayNow][_user].add(_amount);
        bool updated;
        for(uint256 i = 0; i < 3; i++){
            address topUser = dayTopUsers[_dayNow][i];
            if(topUser == _user){
                _reOrderTop(_dayNow);
                updated = true;
                break;
            }
        }
        if(!updated){
            address lastUser = dayTopUsers[_dayNow][2];
            if(userLayer1DayDeposit[_dayNow][lastUser] < userLayer1DayDeposit[_dayNow][_user]){
                dayTopUsers[_dayNow][2] = _user;
                _reOrderTop(_dayNow);
            }
        }
    }

    function _reOrderTop(uint256 _dayNow) private {
        for(uint256 i = 3; i > 1; i--){
            address topUser1 = dayTopUsers[_dayNow][i - 1];
            address topUser2 = dayTopUsers[_dayNow][i - 2];
            uint256 amount1 = userLayer1DayDeposit[_dayNow][topUser1];
            uint256 amount2 = userLayer1DayDeposit[_dayNow][topUser2];
            if(amount1 > amount2){
                dayTopUsers[_dayNow][i - 1] = topUser2;
                dayTopUsers[_dayNow][i - 2] = topUser1;
            }
        }
    }

    function _removeInvalidDeposit(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        address upline = user.referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                if(userInfo[upline].teamTotalDeposit > _amount){
                    userInfo[upline].teamTotalDeposit = userInfo[upline].teamTotalDeposit.sub(_amount);
                }else{
                    userInfo[upline].teamTotalDeposit = 0;
                }
                if(upline == defaultRefer) break;
                upline = userInfo[upline].referrer;
            }else{
                break;
            }
        }
    }

    function _updateReferInfo(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        address upline = user.referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                userInfo[upline].teamTotalDeposit = userInfo[upline].teamTotalDeposit.add(_amount);
                _updateLevel(upline);
                if(upline == defaultRefer) break;
                upline = userInfo[upline].referrer;
            }else{
                break;
            }
        }
    }

    function _updateLevel(address _user) private {
        UserInfo storage user = userInfo[_user];
        uint256 levelNow = _calLevelNow(_user);
        if(levelNow > user.level){
            user.level = levelNow;
            if(levelNow == 4){
                level4Users.push(_user);
            }
        }
    }

    function _calLevelNow(address _user) private view returns(uint256) {
        UserInfo storage user = userInfo[_user];
        uint256 total = user.totalDeposit;
        uint256 levelNow;
        if(total >= 1000e18){
            (uint256 maxTeam, uint256 otherTeam, ) = getTeamDeposit(_user);
            if(total >= 2000e18 && user.teamNum >= 200 && maxTeam >= 50000e18 && otherTeam >= 50000e18){
                levelNow = 5;
            }else if(user.teamNum >= 50 && maxTeam >= 10000e18 && otherTeam >= 10000e18){
                levelNow = 4;
            }else{
                levelNow = 3;
            }
        }else if(total >= 500e18){
            levelNow = 2;
        }else if(total >= 50e18){
            levelNow = 1;
        }

        return levelNow;
    }

    function _deposit(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        require(user.referrer != address(0), "register first");
        require(_amount >= minDeposit, "less than min");
        require(_amount.mod(minDeposit) == 0 && _amount >= minDeposit, "mod err");
        require(user.maxDeposit == 0 || _amount >= user.maxDeposit, "less before");

        if(user.maxDeposit == 0){
            user.maxDeposit = _amount;
        }else if(user.maxDeposit < _amount){
            user.maxDeposit = _amount;
        }

        _distributeDeposit(_amount);

        if(user.totalDeposit == 0){
            uint256 dayNow = getCurDay();
            dayLuckUsers[dayNow].push(_user);
            dayLuckUsersDeposit[dayNow].push(_amount);

            _updateTopUser(user.referrer, _amount, dayNow);
        }

        depositors.push(_user);

        user.totalDeposit = user.totalDeposit.add(_amount);
        user.totalFreezed = user.totalFreezed.add(_amount);

        _updateLevel(msg.sender);

        uint256 addFreeze = (orderInfos[_user].length.div(2)).mul(timeStep);
        if(addFreeze > maxAddFreeze){
            addFreeze = maxAddFreeze;
        }
        uint256 unfreezeTime = block.timestamp.add(dayPerCycle).add(addFreeze);
        orderInfos[_user].push(OrderInfo(
            _amount, 
            block.timestamp, 
            unfreezeTime,
            false
        ));

        _unfreezeFundAndUpdateReward(msg.sender, _amount);

        distributePoolRewards();

        _updateReferInfo(msg.sender, _amount);

        _updateReward(msg.sender, _amount);

        _releaseUpRewards(msg.sender, _amount);

        uint256 bal = busd.balanceOf(address(this));
        _balActived(bal);
        if(isFreezeReward){
            _setFreezeReward(bal);
        }
    }

    function _unfreezeFundAndUpdateReward(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        bool isUnfreezeCapital;
        for(uint256 i = 0; i < orderInfos[_user].length; i++){
            OrderInfo storage order = orderInfos[_user][i];
            if(block.timestamp > order.unfreeze  && order.isUnfreezed == false && _amount >= order.amount){
                order.isUnfreezed = true;
                isUnfreezeCapital = true;

                if(user.totalFreezed > order.amount){
                    user.totalFreezed = user.totalFreezed.sub(order.amount);
                }else{
                    user.totalFreezed = 0;
                }

                _removeInvalidDeposit(_user, order.amount);

                uint256 staticReward = order.amount.mul(dayRewardPercents).mul(dayPerCycle).div(timeStep).div(baseDivider);
                if(isFreezeReward){
                    if(user.totalFreezed > user.totalRevenue){
                        uint256 leftCapital = user.totalFreezed.sub(user.totalRevenue);
                        if(staticReward > leftCapital){
                            staticReward = leftCapital;
                        }
                    }else{
                        staticReward = 0;
                    }
                }
                rewardInfo[_user].capitals = rewardInfo[_user].capitals.add(order.amount);

                rewardInfo[_user].statics = rewardInfo[_user].statics.add(staticReward);

                user.totalRevenue = user.totalRevenue.add(staticReward);

                break;
            }
        }

        if(!isUnfreezeCapital){ 
            RewardInfo storage userReward = rewardInfo[_user];
            if(userReward.level5Freezed > 0){
                uint256 release = _amount;
                if(_amount >= userReward.level5Freezed){
                    release = userReward.level5Freezed;
                }
                userReward.level5Freezed = userReward.level5Freezed.sub(release);
                userReward.level5Released = userReward.level5Released.add(release);
                user.totalRevenue = user.totalRevenue.add(release);
            }
        }
    }

    function _distributeStarPool() private {
        uint256 level4Count;
        for(uint256 i = 0; i < level4Users.length; i++){
            if(userInfo[level4Users[i]].level == 4){
                level4Count = level4Count.add(1);
            }
        }
        if(level4Count > 0){
            uint256 reward = starPool.div(level4Count);
            uint256 totalReward;
            for(uint256 i = 0; i < level4Users.length; i++){
                if(userInfo[level4Users[i]].level == 4){
                    rewardInfo[level4Users[i]].star = rewardInfo[level4Users[i]].star.add(reward);
                    userInfo[level4Users[i]].totalRevenue = userInfo[level4Users[i]].totalRevenue.add(reward);
                    totalReward = totalReward.add(reward);
                }
            }
            if(starPool > totalReward){
                starPool = starPool.sub(totalReward);
            }else{
                starPool = 0;
            }
        }
    }

    function _distributeLuckPool(uint256 _dayNow) private {
        uint256 dayDepositCount = dayLuckUsers[_dayNow - 1].length;
        if(dayDepositCount > 0){
            uint256 checkCount = 10;
            if(dayDepositCount < 10){
                checkCount = dayDepositCount;
            }
            uint256 totalDeposit;
            uint256 totalReward;
            for(uint256 i = dayDepositCount; i > dayDepositCount.sub(checkCount); i--){
                totalDeposit = totalDeposit.add(dayLuckUsersDeposit[_dayNow - 1][i - 1]);
            }

            for(uint256 i = dayDepositCount; i > dayDepositCount.sub(checkCount); i--){
                address userAddr = dayLuckUsers[_dayNow - 1][i - 1];
                if(userAddr != address(0)){
                    uint256 reward = luckPool.mul(dayLuckUsersDeposit[_dayNow - 1][i - 1]).div(totalDeposit);
                    totalReward = totalReward.add(reward);
                    rewardInfo[userAddr].luck = rewardInfo[userAddr].luck.add(reward);
                    userInfo[userAddr].totalRevenue = userInfo[userAddr].totalRevenue.add(reward);
                }
            }
            if(luckPool > totalReward){
                luckPool = luckPool.sub(totalReward);
            }else{
                luckPool = 0;
            }
        }
    }

    function _distributeTopPool(uint256 _dayNow) private {
        uint16[3] memory rates = [5000, 3000, 2000];
        uint72[3] memory maxReward = [2000e18, 1000e18, 500e18];
        uint256 totalReward;
        for(uint256 i = 0; i < 3; i++){
            address userAddr = dayTopUsers[_dayNow - 1][i];
            if(userAddr != address(0)){
                uint256 reward = topPool.mul(rates[i]).div(baseDivider);
                if(reward > maxReward[i]){
                    reward = maxReward[i];
                }
                rewardInfo[userAddr].top = rewardInfo[userAddr].top.add(reward);
                userInfo[userAddr].totalRevenue = userInfo[userAddr].totalRevenue.add(reward);
                totalReward = totalReward.add(reward);
            }
        }
        if(topPool > totalReward){
            topPool = topPool.sub(totalReward);
        }else{
            topPool = 0;
        }
    }

    function _distributeDeposit(uint256 _amount) private {
        uint256 fee = _amount.mul(feePercents).div(baseDivider);
        busd.transfer(feeReceivers[0], fee.div(2));
        busd.transfer(feeReceivers[1], fee.div(2));
        uint256 luck = _amount.mul(luckPoolPercents).div(baseDivider);
        luckPool = luckPool.add(luck);
        uint256 star = _amount.mul(starPoolPercents).div(baseDivider);
        starPool = starPool.add(star);
        uint256 top = _amount.mul(topPoolPercents).div(baseDivider);
        topPool = topPool.add(top);
    }

    function _updateReward(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        address upline = user.referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                uint256 newAmount = _amount;
                if(upline != defaultRefer){
                    uint256 maxFreezing = getMaxFreezing(upline);
                    if(maxFreezing < _amount){
                        newAmount = maxFreezing;
                    }
                }
                RewardInfo storage upRewards = rewardInfo[upline];
                uint256 reward;
                if(i > 4){
                    if(userInfo[upline].level > 4){
                        reward = newAmount.mul(level5Percents[i - 5]).div(baseDivider);
                        upRewards.level5Freezed = upRewards.level5Freezed.add(reward);
                    }
                }else if(i > 0){
                    if( userInfo[upline].level > 3){
                        reward = newAmount.mul(level4Percents[i - 1]).div(baseDivider);
                        upRewards.level4Freezed = upRewards.level4Freezed.add(reward);
                    }
                }else{
                    reward = newAmount.mul(directPercents).div(baseDivider);
                    upRewards.directs = upRewards.directs.add(reward);
                    userInfo[upline].totalRevenue = userInfo[upline].totalRevenue.add(reward);
                }
                if(upline == defaultRefer) break;
                upline = userInfo[upline].referrer;
            }else{
                break;
            }
        }
    }

    function _releaseUpRewards(address _user, uint256 _amount) private {
        UserInfo storage user = userInfo[_user];
        address upline = user.referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                uint256 newAmount = _amount;
                if(upline != defaultRefer){
                    uint256 maxFreezing = getMaxFreezing(upline);
                    if(maxFreezing < _amount){
                        newAmount = maxFreezing;
                    }
                }

                RewardInfo storage upRewards = rewardInfo[upline];
                if(i > 0 && i < 5 && userInfo[upline].level > 3){
                    if(upRewards.level4Freezed > 0){
                        uint256 level4Reward = newAmount.mul(level4Percents[i - 1]).div(baseDivider);
                        if(level4Reward > upRewards.level4Freezed){
                            level4Reward = upRewards.level4Freezed;
                        }
                        upRewards.level4Freezed = upRewards.level4Freezed.sub(level4Reward); 
                        upRewards.level4Released = upRewards.level4Released.add(level4Reward);
                        userInfo[upline].totalRevenue = userInfo[upline].totalRevenue.add(level4Reward);
                    }
                }

                if(i >= 5 && userInfo[upline].level > 4){
                    if(upRewards.level5Left > 0){
                        uint256 level5Reward = newAmount.mul(level5Percents[i - 5]).div(baseDivider);
                        if(level5Reward > upRewards.level5Left){
                            level5Reward = upRewards.level5Left;
                        }
                        upRewards.level5Left = upRewards.level5Left.sub(level5Reward); 
                        upRewards.level5Freezed = upRewards.level5Freezed.add(level5Reward);
                    }
                }
                upline = userInfo[upline].referrer;
            }else{
                break;
            }
        }
    }

    function _balActived(uint256 _bal) private {
        for(uint256 i = balDown.length; i > 0; i--){
            if(_bal >= balDown[i - 1]){
                balStatus[balDown[i - 1]] = true;
                break;
            }
        }
    }

    function _setFreezeReward(uint256 _bal) private {
        for(uint256 i = balDown.length; i > 0; i--){
            if(balStatus[balDown[i - 1]]){
                uint256 maxDown = balDown[i - 1].mul(balDownRate[i - 1]).div(baseDivider);
                if(_bal < balDown[i - 1].sub(maxDown)){
                    isFreezeReward = true;
                }else if(isFreezeReward && _bal >= balRecover[i - 1]){
                    isFreezeReward = false;
                }
                break;
            }
        }
    }
}

After deployment, I interacted with this contract using Web3.js from the frontend.

⚙️ PHP Backend Integration

Even though Web3 is often associated with Node.js, I used PHP for its maturity and fast development cycle.

The backend handles:

Wallet signature verification

API endpoints for user interactions

Optional database logging

I used ext-curl to interact with blockchain nodes (like BSC RPC) and keccak256 libraries for signature verification.

🐳 Dockerizing the App

✅ Backend Dockerfile

FROM php:8.2-apache
COPY . /var/www/html/
EXPOSE 80

✅ Docker Compose Setup

version: '3.8'

services:
    web:
        image: php:8.2-apache
        container_name: php-fizzyfy-container2
        ports:
          - "8083:80"
        volumes:
          - ./:/var/www/html/

✅ Docker Compose Setup (Local)

version: '3.8'

services:
  php-backend:
    build: ./php-backend
    ports:
      - "8080:80"

  frontend:
    build: ./frontend
    ports:
      - "3000:3000"

  ganache:
    image: trufflesuite/ganache
    ports:
      - "8545:8545"

Run everything locally with:

docker-compose up -d

🌐 Frontend Interaction with Web3.js

const web3 = new Web3(window.ethereum);

async function connectWallet() {
  const accounts = await ethereum.request({ method: 'eth_requestAccounts' });
  console.log('Connected account:', accounts[0]);
}

The frontend connects to MetaMask and reads data from the deployed contract on BSC testnet.

📦 Deployment Options

This app is fully containerized and can be deployed to:

AWS EC2/ECS
GCP Cloud Run
DigitalOcean App Platform
Or even Kubernetes using Helm charts

🛠️ Next Steps

Integrate NFTs with ERC-721
Add WalletConnect support
CI/CD with GitHub Actions

🧠 Lessons Learned

PHP can still shine in Web3 projects when used wisely
Docker ensures a consistent and portable development environment
Binance Smart Chain is a fast, low-cost option for Ethereum-compatible dApps

👋 Let’s Connect

If you're building DApps and have a background in PHP or traditional stacks, I’d love to connect and exchange ideas.

💼 LinkedIn: https://www.linkedin.com/in/surender-gupta/
💻 GitHub: https://github.com/surendergupta

Feel free to drop comments or suggestions below!

How we create project for devops that help me to find job in devops engineer role

Surender Gupta — Sat, 17 May 2025 15:31:29 +0000

🚀 Hire a PHP Laravel Developer to Build Scalable Web Apps, Admin Panels, and DApps – 7+ Years of Experience

Surender Gupta — Sat, 17 May 2025 14:53:24 +0000

🚀 Hire a PHP Laravel Developer to Build Scalable Web Apps, Admin Panels, and DApps – 7+ Years of Experience

Hi, I'm Surender, a full-stack web developer with over 7 years of experience crafting reliable, scalable, and secure web applications using PHP, Laravel, CodeIgniter, and modern cloud/backend tools.

Whether you're building a dynamic website, an admin dashboard, or even a decentralized app (DApp), I bring both experience and technical depth to the table.

💼 Services I Offer

I help clients turn their ideas into fully functional web apps with:

✅ Full-stack development using PHP (Laravel, CodeIgniter)
✅ REST API & backend development
✅ Admin panels and dashboards
✅ Web3 DApps (Ethereum integration, Solidity basics)
✅ Database design & optimization (MySQL, MongoDB)
✅ Bug fixing, refactoring, and performance tuning
✅ Deployment & CI/CD with GitHub Actions or Jenkins

👉 Check out my Fiverr Gig here

🛠️ My Tech Stack

Category	Tools
Backend	PHP, Laravel, CodeIgniter, Nodejs
Frontend	Reactjs, HTML, Bootstrap, Tailwind
Web3	Solidity basics, Web3.js
Database	MySQL, MongoDB
DevOps	Docker, GitHub Actions, Jenkins
Deployment	GCP, AWS EC2, Shared Hosting
Version Control	Git, GitHub

🧪 Case Studies & Sample Work

🔹 Custom CRM with Laravel

Developed a full-featured CRM system for a logistics company, including user roles, ticketing, and reporting. Integrated automated backups and role-based access control.

🔹 CodeIgniter Admin Panel

Built a lightweight admin panel for an eCommerce platform using CodeIgniter. Features included product management, user access, and sales reports.

🔹 DApp MVP

Helped a blockchain startup create a proof-of-concept DApp integrating basic smart contract interactions using Web3.js and Laravel.

📞 Want to Work With Me?

If you're building something exciting or need help fixing/optimizing an existing web application — let’s connect!

✅ Visit My Fiverr Profile

💬 Or reach out via LinkedIn or Email (add your contact/email here if applicable)

✍️ Why Clients Work With Me

Clear and fast communication
Clean, maintainable code
On-time delivery
Flexible and open to feedback
Affordable pricing with top-tier quality

Let’s build something great together!

🚀 Terraform Directory Structure – The Right Way!

Surender Gupta — Thu, 15 May 2025 04:43:24 +0000

When building cloud infrastructure using Terraform, your directory structure matters more than you think.

A well-structured Terraform layout helps you:

Scale easily across environments
Reuse code with modules
Avoid production mistakes
Automate safely with scripts

In this post, I’ll show you the best practices I follow for organizing Terraform projects used in Dev, Stage, and Prod.

📁 1. Environment Separation: Dev, Stage, Prod

Organize each environment in its own folder:

terraform/
├── dev/
│   ├── main.tf
│   ├── variables.tf
│   ├── outputs.tf
├── stage/
│   └── ...
├── prod/
│   └── ...
└── env/
    ├── dev.tfvars
    ├── stage.tfvars
    └── prod.tfvars

✅ Pro tip: Keep .tfvars values in a separate env/ directory for cleaner management.

Why it matters:

Prevents accidental changes to production
Clear separation of responsibilities
Easier CI/CD integration

📦 2. Reuse Code with Modules

Instead of copying and pasting the same code, create reusable modules:

modules/
├── vpc/
│   ├── main.tf
│   ├── variables.tf
│   └── outputs.tf
├── ec2/
│   └── ...

Usage example:

module "vpc" {
  source     = "../../modules/vpc"
  cidr_block = var.vpc_cidr
}

Benefits:
💡 Define once, use everywhere
🔄 Ensures consistency across environments
🧩 Simplifies testing and debugging

🤖 3. Automate with Scripts

Use shell scripts to handle Terraform operations like init, apply, and destroy.

scripts/
├── init.sh        # terraform init
├── plan.sh        # terraform plan
├── apply.sh       # terraform apply
└── teardown.sh    # terraform destroy

Why script it?
⏱️ Saves time
🔐 Reduces manual error
⚙️ Fits into CI/CD pipelines seamlessly

🧠 4. Core Terraform Files

Each environment/module folder typically contains:

main.tf: Infrastructure definitions
variables.tf: Variable declarations
outputs.tf: Exposed outputs
terraform.tfvars: Variable values (optional if using env/*.tfvars)
provider.tf: Cloud provider setup
backend.tf: Remote state configuration

🛡️ Store state remotely (e.g., S3 + DynamoDB) for security and team collaboration.

🖼️ Visual: Terraform Directory Structure

Infographic: High-level layout of a scalable Terraform project

✅ Summary: Why This Structure Works

✅ Modular and reusable
✅ Safer deployments
✅ DevOps- and CI/CD-friendly
✅ Environment-ready (Dev, Stage, Prod)

💬 What’s your Terraform setup look like?

Do you structure things differently?

Have tips for managing multiple environments or state files?

Let’s share ideas in the comments 💬👇

#Terraform #DevOps #InfrastructureAsCode #AWS #GCP #Azure #CloudEngineering #SRE #CI/CD #IaC

🚀 From Zero to Hero: Deploying a FastAPI Backend on Google Cloud Run with CI/CD, Docker & MongoDB

Surender Gupta — Fri, 02 May 2025 11:02:06 +0000

Hey Devs! 👋

This week, I took on a fun but powerful challenge — containerizing a FastAPI backend, wiring up MongoDB, pushing to Google Cloud Run, and fully automating it with GitHub Actions. And let me tell you — it feels GOOD to ship like a pro 💪

Here’s how I did it (and how you can too).

🧠 TL;DR

👉 FastAPI backend for a logging/incident tracking service
👉 Dockerized and deployed to Google Cloud Run
👉 MongoDB Atlas for persistence
👉 GitHub Actions for zero-touch deployments
👉 Full CI/CD pipeline using Artifact Registry + Cloud Run
👉 Production-ready, scalable, and auto-deployed on every push!

🔧 Tech Stack

FastAPI – blazing fast Python framework
Docker – containerizing like a boss
MongoDB Atlas – cloud-hosted database
Google Cloud Run – serverless container deployment
GitHub Actions – CI/CD pipelines for automation
Google Artifact Registry – to store and manage container images

💻 What I Built

A REST API to log incidents/alerts that:

Accepts structured JSON data via POST
Stores it in a MongoDB database
Returns clean, structured responses
Has built-in Swagger UI (/docs)

🌐 Live Demo:
🔗 https://fastapi-agent-154172965587.us-central1.run.app
(Play around with /docs – it's interactive!)

🐳 Dockerization in a Nutshell

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Simple. Fast. Efficient.

☁️ Deployment to Google Cloud Run

Build Docker image
Push to Artifact Registry
Deploy to Cloud Run via GitHub Actions

I configured service accounts, IAM roles, and tokens securely to allow the GitHub pipeline to deploy like magic. ✨

⚙️ CI/CD with GitHub Actions

name: Deploy to Cloud Run

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Google Cloud SDK
        uses: google-github-actions/setup-gcloud@v1
        with:
          project_id: ${{ secrets.GCP_PROJECT_ID }}
          service_account_key: ${{ secrets.GCP_SA_KEY }}
          export_default_credentials: true

      - name: Docker build & push
        run: |
          docker build -t REGION-docker.pkg.dev/PROJECT_ID/REPO/fastapi-backend .
          docker push REGION-docker.pkg.dev/PROJECT_ID/REPO/fastapi-backend

      - name: Deploy to Cloud Run
        run: |
          gcloud run deploy fastapi-backend \
            --image REGION-docker.pkg.dev/PROJECT_ID/REPO/fastapi-backend \
            --platform managed \
            --region REGION \
            --allow-unauthenticated

🔐 Secrets are managed via GitHub’s encrypted secret manager.

📖 Full Deep Dive (Step-by-Step)

👉 I broke down every single detail in this Medium article:
📖 How I Containerized and Deployed a FastAPI Backend on Google Cloud Run (Like a Pro)

💻 Source Code on GitHub

Browse, fork, and ⭐ the repo here:
🔗 github.com/surendergupta/task_backend_devops

🙌 Final Thoughts

✅ Cloud Run made scaling effortless
✅ GitHub Actions made CI/CD painless
✅ FastAPI made building APIs fun again
✅ Docker made everything consistent

If you're a Python/DevOps/cloud enthusiast, I highly recommend trying this stack combo out. You’ll learn a ton!

🔁 Let’s Connect

If you enjoyed this, leave a ❤️ or drop a comment below!
Got questions? I’m happy to help or collaborate.

Let’s build cool things together 🙌

🚀 How I Deployed a Self-Hosted n8n Instance on Google Cloud Free Tier (with Docker Compose + Script Automation)

Surender Gupta — Fri, 02 May 2025 10:27:47 +0000

Hey DEV community! 👋

I'm a DevOps Engineer obsessed with automation, cloud efficiency, and squeezing every drop out of free tiers. Recently, I deployed n8n, the powerful open-source workflow automation tool, on a GCP e2-micro instance (aka Free Tier heaven) — and it’s running securely, persistently, and flawlessly.

Let me show you how I did it — step-by-step, script-included, and cloud-cost-friendly. 💸☁️

💡 Why n8n?

If Zapier and Node-RED had a baby, it would be n8n. You can automate everything — from APIs to Slack workflows — and run it self-hosted for full control and zero SaaS limits.

🧰 Stack & Setup

🧱 Google Cloud Platform Free Tier (e2-micro VM)
🐳 Docker + Docker Compose
🔐 Basic Auth + Secured SSH
📁 Persistent storage via Docker volumes
⚙️ Automated install via shell script

🔧 Full Guide on Medium

I documented everything — provisioning the VM, opening the right ports, installing Docker, configuring .env, securing the VM, and even automating it all via a deploy script.

👉 Read the full tutorial here:

📖 https://medium.com/@gupta.surender.1990/how-to-deploy-a-self-hosted-n8n-instance-on-google-cloud-free-tier-with-docker-compose-63f7fa1a40db

🖥️ TL;DR — The Highlights

✅ Create an Ubuntu 22.04 e2-micro instance
✅ Install Docker + Compose
✅ Setup .env with Basic Auth
✅ Mount persistent volume
✅ Open only ports 22 and 5678
✅ Secure SSH (no root login, key-based access only)
✅ Hit your instance on http://:5678 and start building!

🧪 Bonus: One-Command Deploy Script

Want it automated? I built a deploy script that:

Installs Docker & Compose
Sets up environment variables
Builds your docker-compose.yml
Starts the n8n container — ready to go!

Just run:

chmod +x n8n-deploy-gcp.sh
./n8n-deploy-gcp.sh

And boom 💥, you’ve got a self-hosted automation engine for free.

🔒 Security Reminder

Please don’t forget to:

Use strong Basic Auth credentials
Restrict open ports in your GCP firewall
Disable password-based SSH login Secure automation is happy automation. 😄

🤝 Let’s Connect

If you:

❤️ n8n
💻 Love DevOps
🧠 Automate all the things

Let’s chat! Drop your feedback, questions, or improvements in the comments.

🚀 Go Read It & Deploy Your Own for FREE!

👉 https://medium.com/@gupta.surender.1990/how-to-deploy-a-self-hosted-n8n-instance-on-google-cloud-free-tier-with-docker-compose-63f7fa1a40db