# Grayhat Blog Author: Syed Abdullah Nasir

> Expanded public blog context for posts by Syed Abdullah Nasir.

## Page

- [Syed Abdullah Nasir Author](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/author/nasirabdullahsyed)
- [Syed Abdullah Nasir Author LLM Context](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/author/nasirabdullahsyed/llms.txt)
- [Root LLM Context](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/llms.txt)
- [Root Full LLM Context](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/llms-full.txt)
- [Author API](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/api/public/v1/authors/nasirabdullahsyed)

## Author Details

- Name: Syed Abdullah Nasir
- Location: Islamabad, Pakistan
- Website: https://syedabdullahnasir.vercel.app
- Post count in current snapshot: 3
- Bio: Software Engineer 1 at Grayhat. Making cool shit since 2023. 

Medium blog: medium.com/@nasirabdullahsyed 

## Current Posts

- [Full Stack Deployment: Setting Up CI/CD for Node.js Applications on AWS with Custom Domains](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/full-stack-deployment-setting-up-ci-cd-for-node-js-applications-on-aws-with-custom-domains) - This comprehensive guide will walk you through establishing a professional CI/CD pipeline for Node.js applications on AWS EC2, complete with custom domain configuration.
- [Create Multiplayer Web Games, Faster](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/create-multiplayer-web-games-faster) - We built a React/Vite-powered game engine, powered by Playroom.
- [The Evolution of SecOps, DevOps, DevSecOps, GitOps, and Developer Experience](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/the-evolution-of-secops-devops-devsecops-gitops-and-developer-experience) - In the fast-paced world of software development, staying ahead of the curve is essential. As build times shorten, Sprint cycles shorten, and remote culture rises, the management of the Software Development Lifecycle is rapidly being transferred from the hands of managers into the hands of developers themselves.

Auditing by a manager is no longer a one-time thing; metrics of software quality like security, performance, code quality, and testing have been delegated to the developers themselves. T

## Child Route Content

### [Full Stack Deployment: Setting Up CI/CD for Node.js Applications on AWS with Custom Domains](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/full-stack-deployment-setting-up-ci-cd-for-node-js-applications-on-aws-with-custom-domains)

- Slug: `full-stack-deployment-setting-up-ci-cd-for-node-js-applications-on-aws-with-custom-domains`
- Published: 2025-05-13T15:00:41.000+05:00
- Updated: 2025-05-13T15:00:41.000+05:00
- Reading time: 9 min
- Tags: DevOps, Cloud, Automation, Deployment, Development, Software Engineering, Amazon Web Services (AWS)
- Authors: Syed Abdullah Nasir
- Visibility: public

💡This is a repost from Abdullah's original blog on Medium. Check it out here: https://medium.com/@nasirabdullahsyed/full-stack-deployment-setting-up-ci-cd-for-node-js-applications-on-aws-with-custom-domains-8924217cb1a4In today’s competitive digital landscape, the ability to deploy applications quickly and reliably is essential for development teams. This comprehensive guide will walk you through establishing a professional CI/CD pipeline for Node.js applications on AWS EC2, complete with custom domain configuration. Whether you’re a solo developer or part of a larger team, these automation techniques will streamline your workflow and ensure consistent deployments.

# Understanding CI/CD and Its Benefits

Continuous Integration and Continuous Deployment (CI/CD) revolutionizes the software development lifecycle by automating testing and deployment processes. Instead of manually transferring files and restarting services, a well-configured CI/CD pipeline handles these tedious tasks automatically when you push code changes to your repository.

The benefits include:

- Reduced human error during deployments
- Faster release cycles
- Consistent testing before production deployment
- Easier rollbacks when issues arise
- Better collaboration within development teams

# Prerequisites

Before we dive into implementation, ensure you have:

- An active AWS account with permissions to create and manage EC2 instances
- A Node.js application ready for deployment (either existing or new)
- A GitHub repository containing your application code
- A domain name (if implementing the custom domain section)

# Part 1: Setting Up Your AWS Infrastructure

# Launching an EC2 Instance

Let’s begin by creating the server that will host your application:

- Log in to your AWS Console and navigate to the EC2 Dashboard

*****AWS EC2 Dashboard****- Click the “Launch Instance” button
- Select an appropriate Amazon Machine Image (AMI). For Node.js applications, Ubuntu or Amazon Linux 2 are excellent choices due to their stability and widespread support

*****EC2 Launch Instance Section 2 — Application and OS Images (Amazon Machine Image)****- Choose an instance type. For smaller applications or testing environments, the free-tier eligible t3.micro is sufficient. Production applications may require more resources depending on traffic expectations

*****EC2 Launch Instance Section 3 — Instance type****- Configure a key pair. This is critical for secure SSH access to your instance. Either create a new key pair or select an existing one, but ensure you download the private key file (.pem) if creating a new one

*****EC2 Launch Instance Section 4 — Key pair (login)*********EC2 Launch Instance Section 4.1 — Key pair (login) — Create key pair Popup****- Configure security groups to allow the necessary network traffic:
- SSH (port 22): Restrict to your IP address for security
- HTTP (port 80): Allow from anywhere (0.0.0.0/0)
- HTTPS (port 443): Allow from anywhere (0.0.0.0/0)

*****EC2 Launch Instance Section 5 — Network settings****- Configure storage settings:
- For most Node.js applications, the default storage allocation (8 GB) is sufficient
- Use General Purpose SSD (gp2 or gp3) for balanced performance
- Consider increasing storage if you anticipate **storing large media files**, **accumulating extensive logs**, **hosting databases locally (though a separate RDS instance is recommended for production)
- **You can always increase storage later if needed

*****EC2 Launch Instance Section 6 — Configure storage****- Launch the instance and note the Public IP address assigned to it

*****EC2 Launch Instance Section 8 — Summary*********EC2 Instance Tab****# Setting Up the Server Environment

After launching your EC2 instance, you’ll need to install the necessary software:

- Connect to your instance via SSH:

*****EC2 Instance — Connect Section — SSH Client Tab****ssh -i /path/to/your-key.pem ubuntu@your-ec2-public-ip

- Update the package repositories:

sudo apt update

- Install Node.js and npm:

sudo apt-get install -y nodejs

- Install Nginx to act as a reverse proxy and check its status:

sudo apt-get install nginx
sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

- Install PM2, a process manager that will keep your Node.js application running:

sudo npm install -g pm2

At this point, navigating to your EC2 instance’s public IP address *http://your-ec2-public-ip/* in a browser should display the default Nginx welcome page, confirming that your web server is working correctly.

# Part 2: Configuring GitHub Actions for CI/CD

GitHub Actions provides an elegant way to implement CI/CD directly within your GitHub repository. We’ll set up a workflow that automatically deploys your application whenever changes are pushed to the main branch.

# Setting Up a Self-Hosted GitHub Runner

Unlike GitHub’s cloud-based runners, a self-hosted runner gives you direct access to your EC2 instance during deployment:

- In your GitHub repository, navigate to Settings > Actions > Runners.

*****GitHub Repository Settings — Actions Tab****- Click “New self-hosted runner”
- Select “Linux” as the operating system.
- Follow the provided instructions to download, configure, and run the GitHub Actions runner on your EC2 instance.

*****GitHub Repository Settings — Actions Tab — New Runners Setup****Once installed, set up the runner as a system service to ensure it runs continuously:

cd ~/actions-runner
sudo ./svc.sh install
sudo ./svc.sh start

Verify that the service is running:

sudo ./svc.sh status

# Creating the GitHub Actions Workflow

Now, create the workflow definition that will trigger your deployments:

- Add your applications environment variables as a GitHub Secret

*****GitHub Repository Settings — Secrets and Variables Tab*********GitHub Repository Settings — Secrets and Variables Tab — New Repository Secret Setup****- In your repository, create a directory structure .github/workflows/
- Add a file named deploy.yml with the following content:

name: Node.js CI/CD

# Trigger the workflow on pushes to the "main" branch
on:
  push:
    branches: [ "main" ]

jobs:
  build:
    # This job runs on your self-hosted runner
    runs-on: self-hosted

    steps:
    # Step 1: Checkout the latest code
    - uses: actions/checkout@v4

    # Step 2: Setup Node.js environment
    - name: Use Node.js 20.x
      uses: actions/setup-node@v3
      with:
        node-version: '20.x'
        cache: 'npm'

    # Step 3: Install dependencies
    - run: npm ci

    # Step 4: Set up environment variables
    # This step assumes you've stored your env variables as GitHub Secrets
    - run: |
        touch .env
        echo "${{ secrets.PROD_ENV }}" > .env

    # Step 5: Build the project if needed
    - run: npm run build --if-present

    # Step 6: Restart the application using PM2
    - run: pm2 restart node-app || pm2 start server.js --name node-app

This workflow performs several important functions:

- Checks out your code on the EC2 instance
- Sets up the appropriate Node.js version
- Installs dependencies with npm ci (which is faster and more reliable than npm install)
- Creates an environment file with your secrets
- Builds your application if needed
- Starts or restarts your application with PM2

# Configuring Nginx as a Reverse Proxy

Now, set up Nginx to direct incoming web traffic to your Node.js application:

sudo nano /etc/nginx/sites-available/default

Replace the default configuration with:

server {
    listen 80;
    server_name _;

    # For API endpoints
    location /api {
        rewrite ^\/api\/(.*)$ /api/$1 break;
        proxy_pass http://localhost:4000; # Adjust port to match your application
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Test the configuration and restart Nginx:

sudo nginx -t
sudo systemctl restart nginx

# Part 3: Adding a Custom Domain

A professional application should have a proper domain name rather than an IP address. Let’s configure your application to use your custom domain.

# Setting Up DNS Records

- Log in to your domain registrar’s dashboard (e.g., Namecheap, GoDaddy, Route 53).
- Navigate to the DNS management section for your domain.
- Create A records pointing to your EC2 instance:
- Type: A Record
- Host: @ (for root domain)
- Value: Your EC2 instance’s public IP address
- TTL: 3600 (or recommended value)
- For the www subdomain:
- Type: A Record
- Host: www
- Value: Your EC2 instance’s public IP address
- TTL: 3600

# Updating Nginx Configuration for Your Domain

- Create a new Nginx configuration file for your domain:

sudo nano /etc/nginx/sites-available/default

- Add the following configuration:

server {
    listen 80;
    server_name your-domain.com www.your-domain.com;

    # For API endpoints
    location /api {
        rewrite ^\/api\/(.*)$ /api/$1 break;
        proxy_pass http://localhost:4000;  # Adjust if needed
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    # For serving static content or frontend
    location / {
        proxy_pass http://localhost:4000;  # Adjust if needed
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

- Enable the new configuration:

sudo ln -s /etc/nginx/sites-available/your-domain.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

# Securing Your Application with SSL/TLS

Adding HTTPS encryption is crucial for modern web applications:

- Install Certbot and the Nginx plugin:

sudo apt update
sudo apt install certbot python3-certbot-nginx

- Obtain and install SSL certificates:

sudo certbot --nginx -d your-domain.com -d www.your-domain.com

- Follow the prompts to complete setup, choosing to redirect all HTTP traffic to HTTPS.
- Certbot automatically configures renewal, but you can test it:

sudo certbot renew --dry-run

After SSL configuration, your Nginx setup will be updated to handle HTTPS connections securely.

# Part 4: Verifying and Testing the Deployment

After completing the setup, it’s time to verify that everything works as expected:

- Push a change to your repository:

git add .
git commit -m "Test CI/CD deployment"
git push origin main

- Monitor the GitHub Actions workflow in your repository’s Actions tab.
- Once the workflow completes, visit your domain or EC2 public IP address to verify that your application is running correctly.
- Check the PM2 status on your EC2 instance:

pm2 status

# Advanced Optimizations

To further enhance your deployment, consider these advanced optimizations:

# Allocating an Elastic IP

An Elastic IP ensures your application remains accessible even if your EC2 instance is restarted:

- In the AWS Console, navigate to EC2 > Elastic IPs.
- Allocate a new Elastic IP address.
- Associate it with your EC2 instance.
- Update your DNS A records to point to this new Elastic IP.

# Implementing a CDN

For applications serving users across different geographic regions, a CDN can significantly improve performance:

- Set up AWS CloudFront or another CDN service.
- Configure the CDN to use your domain as the origin.
- Update your DNS records to point to the CDN distribution.

# Setting Up Monitoring and Logging

Implement monitoring to stay on top of your application’s health:

- Install a monitoring agent like AWS CloudWatch or set up Prometheus.
- Configure alerting for critical metrics like CPU usage, memory utilization, and disk space.
- Set up centralized logging with tools like CloudWatch Logs, ELK Stack, or Graylog.

# Common Troubleshooting Tips

If you encounter issues during setup, check these common problem areas:

- **DNS Resolution Issues**: Use nslookup your-domain.com to verify DNS propagation.
- **Connection Refused Errors**: Check that your security groups allow traffic on the necessary ports.
- **Application Not Running**: Check PM2 logs with pm2 logs node-app.
- **Nginx Configuration Problems**: Review error logs with sudo tail -f /var/log/nginx/error.log.
- **SSL Certificate Issues**: Ensure that Certbot completed successfully and check for certificate errors in browser developer tools.

# Conclusion

You’ve now set up a professional-grade CI/CD pipeline for your Node.js application on AWS EC2, complete with a custom domain and HTTPS encryption. This automation will save you countless hours of manual deployment work while ensuring consistent and reliable updates to your application.

By leveraging GitHub Actions, you’ve created a streamlined workflow that automatically deploys your code whenever changes are pushed to your repository. This approach facilitates rapid iteration and helps maintain a consistent development experience across your team.

The addition of a custom domain with SSL/TLS encryption provides a professional appearance and ensures secure communication between your users and your application. Remember to maintain your infrastructure by keeping your server updated and monitoring your application’s performance.

For more advanced scenarios, consider exploring container-based deployments with Docker and Kubernetes, which can provide even greater flexibility and scalability for complex applications.

Happy coding and deploying!

### [Create Multiplayer Web Games, Faster](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/create-multiplayer-web-games-faster)

- Slug: `create-multiplayer-web-games-faster`
- Published: 2024-05-04T10:31:32.000+05:00
- Updated: 2024-08-31T13:41:49.000+05:00
- Reading time: 2 min
- Tags: Development, Multiplayer Gaming, Gaming, JavaScript, Developer Tools
- Authors: Syed Abdullah Nasir
- Visibility: public

**Open-source Product Announcement! Check out create-multiplayer-game on NPM and GitHub. Currently in alpha.***Imagine this**...*

You have a great idea for your next indie game, and since the world is online-first, you dive into the world of multiplayer game development, but you want to skip the tedious setup process. Sockets? Firebase Realtime DB?

Eventually, you give up on multiplayer, and focus on building a great single-player experience first. When you do, and you put off multiplayer to the end, you end up having to refactor a lot of code to make it "multiplayer-ready".

What if games were built **multiplayer-first**?

That's why we built a React/Vite powered game template, powered by Playroom. It swiftly conjures up a multiplayer game template in React, so you can focus on bringing your gaming vision to life.

npx create-multiplayer-game@latestIt will ask you a few small questions to personalize your game. Have a look.

*Works great with macOS and Linux.**Name Your Game: **First off, we need a name for your masterpiece. What will you call it?

**Project Name: **Need a project name, or are you happy with the default generated one? Feel free to customize it as you like!

**Choose Your Template: **Now, which template suits your fancy? Use your arrow keys to browse the options:

*Option A:*

"vite-react-ts": A ReactJS project with Vite, crafted in TypeScript. It's equipped with PlayroomKit for multiplayer magic, along with an array of game components, sounds, and interactions. Usually the top choice.

*Option B:*

"next-ts'': A NextJS project in TypeScript, powered by PlayroomKit for multiplayer functionality.

Once you've made your choice, sit back as we download your selected template. Then, you'll be greeted with a message: "Project initialized at . Happy Coding!"

### What's next?

- We're building a mechanism for you to keep updating your game, as we improve our templates.
- We're building a useful Chrome DevTool for debugging game states (no more hardcoding or adding "cheats" to go forward in a game).
- Some premium templates with some extra goodies.

Read more here: https://grayhat.studio/games/pricing

*We love open source, bringing useful tech to builders, and contributing to the overall knowledge stream. A lot of our work is R&D-based and on experimental tech. If you're interested in working with or for *Grayhat*, DM or comment!*

**This article was authored by** Syed Abdullah Nasir, **Software Engineer at Grayhat.**

### [The Evolution of SecOps, DevOps, DevSecOps, GitOps, and Developer Experience](https://grayhat-company-blog.grayhatstudio.workers.dev/blog/the-evolution-of-secops-devops-devsecops-gitops-and-developer-experience)

- Slug: `the-evolution-of-secops-devops-devsecops-gitops-and-developer-experience`
- Published: 2023-09-06T16:34:00.000+05:00
- Updated: 2024-05-09T16:35:52.000+05:00
- Reading time: 3 min
- Tags: DevOps, GitOps, SecOps, Software Engineering
- Authors: Syed Abdullah Nasir
- Visibility: public

*OctokittyOpsIn the fast-paced world of software development, staying ahead of the curve is essential. As build times shorten, Sprint cycles shorten, and remote culture rises, the management of the Software Development Lifecycle is rapidly being transferred from the hands of managers into the hands of developers themselves.

Auditing by a manager is no longer a one-time thing; metrics of software quality like security, performance, code quality, and testing have been delegated to the developers themselves. The base unit is now the Pull Request - whenever a chunk of code is added to the main code, it's the team's responsibility to ensure it's good code. This allows developers to consistently improve all the metrics and have a "history" of quality.

Five crucial concepts have emerged in recent years, revolutionizing the way software is developed, secured, and managed. These concepts are SecOps, DevOps, DevSecOps, GitOps, and Developer Experience (DX). In this article, we will explore each of these practices and their significance in modern software development.

**SecOps**

SecOps, short for Security Operations, has become indispensable in today's digital landscape. It encompasses the integration of security practices into the operations of the software development process. The primary goal is to fortify software security by ensuring that security is not an afterthought but a fundamental part of the development pipeline. By embedding security practices from the outset, SecOps minimizes vulnerabilities and strengthens defenses against cyber threats.

**DevOps**

DevOps, a portmanteau of Development and Operations, is all about fostering collaboration and automation within a software development team. It aims to bridge the gap between developers and operations teams, enabling faster development cycles and improved software quality. DevOps practices include continuous integration, continuous delivery, and infrastructure as code, creating a streamlined and efficient development process.

**DevSecOps**

DevSecOps takes the principles of DevOps and adds a crucial layer of security. In today's threat landscape, security cannot be an afterthought. DevSecOps integrates security measures throughout the entire DevOps pipeline, ensuring that security is woven into every stage of development. This proactive approach reduces the risk of vulnerabilities and data breaches, making it a vital practice for safeguarding software in the digital age.

**GitOps**

GitOps leverages the power of version control systems, most notably Git, to manage and automate the deployment, configuration, and monitoring of applications and infrastructure. By treating infrastructure as code and using Git repositories as the single source of truth, GitOps simplifies and streamlines the management of complex systems. This approach enhances traceability, transparency, and collaboration among development and operations teams.

**Developer Experience (DX)**

Developer Experience, or DX, is about creating an environment that empowers developers to do their best work. It encompasses everything from user-friendly development tools and documentation to efficient workflows and supportive team dynamics. A positive DX leads to increased developer productivity and innovation, making it a critical factor in attracting and retaining top talent in the competitive software industry.

**The Synergy**

When these five concepts—SecOps, DevOps, DevSecOps, GitOps, and DX—are combined, they form a holistic approach to software development and operations. DevOps accelerates development cycles, while DevSecOps ensures that security is embedded from the start. GitOps streamlines deployment and management, while a positive DX enhances productivity and innovation. The interplay between these practices creates a secure, efficient, and enjoyable development environment.

## Why Ops?

1. Efficiency: Streamlining complex software development and operations.

2. Speed: Faster development, deployment, and innovation.

3. Security: Integrating security from the start.

4. Agility: Adapting quickly to changing market demands.

5. Cost Reduction: Optimizing resources and reducing operational costs.

6. Developer Productivity: Enhancing the developer experience to attract top talent.

Numerous organizations have successfully implemented these practices to transform their software development processes. From tech giants to startups, the adoption of DevOps, DevSecOps, GitOps, and a positive DX has led to faster delivery of high-quality software with enhanced security features.

**Google's DevOps Transformation**

Google adopted DevOps principles to enhance its software development and operations. They reduced their average release cycle from months to days, resulting in faster feature delivery and improved service reliability. This transformation allowed Google to maintain its leadership in the tech industry.

**Netflix's Continuous Deployment with DevOps**

Netflix implemented DevOps practices to achieve continuous deployment. They can now release updates and new features to their streaming platform hundreds of times a day. This rapid iteration keeps customers engaged and satisfied, making Netflix a global entertainment giant.

**Target's DevSecOps for Enhanced Security**

Target integrated DevSecOps to bolster its cybersecurity efforts. By proactively addressing security vulnerabilities in the development process, they fortified their systems against threats. This approach helped Target rebuild trust with customers after a significant data breach, showcasing the power of DevSecOps in safeguarding sensitive data.

**Conclusion**

In the ever-evolving landscape of software development, staying updated with these transformative practices is essential. SecOps, DevOps, DevSecOps, GitOps, and DX are not just buzzwords; they represent the future of efficient, secure, and enjoyable software development. Embracing these concepts can help your organization stay competitive and thrive in the digital age.

**Author: **Syed Abdullah Nasir