PSR.COM

Making a Local Dev Server accessible via Public Domain using Cloudflare Tunnel

2026-01-30T01:53:00.007+05:30

Hi all,

Today, we are going to discuss how you can publicly access the local running server with a domain and Cloudflare tunnel.

Pre-requisites

Domain
DNS on Cloudflare
Cloudflare One account access
Local server

Set up the environment

Application

Make sure your application runs locally on a port like 8000,9000 etc.

Cloudflare Tunnel

Log in to your Cloudflare One account.
Go to "Zero Trust".
Expand Networks and select Connectors.
Click on “Create a tunnel”.
Select “Cloudflared”.
Give a name to your tunnel.
Click on “Save”.
In the "Choose your environment" section, select the environment where the server is running.
Follow the instructions to install and run a connector.
Here, you need to move to your server machine.
Open the terminal and perform the instructions to install the "cloudflared" tool.
Run using the token (part of the command).
Once the installation is completed. Click on Save.

Add IP/CIDR

Edit the tunnel to add the IP/CIDR.
Choose based on your local DHCP.

Published application routes

Click on “Add a published application route”.
Give an optional subdomain.
Select the domain from the dropdown.

You need to have your domain managed by Cloudflare (DNS).

An optional path to make sure you have a frontend and a backend that work together.
Under service, select Type as HTTP, and your local machine server port.
Select the URL of the server application, including the localport.

localhost:9000

Click on “Save”.

Note: If you have a frontend and a backend, then you need to add one more application route.

In my scenario, the frontend path is * with localhost:9001, and the backend path is api/* with localhost:8000.

Run the tunnel

Make sure your local web server is running
Log in to cloudflared

cloudflared tunnel login

Authorize the tunnel on the web browser post login

List the tunnels

cloudflared tunnel list

Get the tunnel token from the tunnel you created in Cloudflare connectors
Run the command on the local terminal

cloudflared tunnel run --token eyJhIjoiM2...

Now, you should be able to browse your configured subdomain with your local web server content.

Troubleshooted issue

If the frontend with path "/*" is above the backend route, then your backend APIs will never be reached.

So, "move up" the backend with "/api/*" path above the frontend to serve the requests.

Feel free to reach out to me if you have any doubts and clarifications needed at my email psrdotcom@gmail.com

Migrate from Nginx to Caddy for SSL auto-renewal in Amazon AWS EC2

2025-11-06T13:36:00.000+05:30

Dear friends,

Today, we will see a simple migration with less configuration of SSL auto-renewal.

I was using Nginx for SSL auto-renewal using certbot. Every 90 days, the renewal code should run, I made one more service it.

I have come across Caddy, which does an auto-renewal of SSL automatically with certbot. Reducing efforts and making the system smooth.

Follow the steps below

Stop and disable the Nginx

sudo systemctl stop nginx
sudo systemctl disable nginx

Install the Caddy

In EC2, if you are running Amazon Linux, then execute the following to install Caddy.

sudo yum -y install yum-plugin-copr
sudo yum -y copr enable @caddy/caddy epel-8-$(arch)
sudo yum -y install caddy

Edit and configure the Caddyfile

Usually, it will be in the path /etc/caddy/Caddyfile

sudo vi /etc/caddy/Caddyfile

I have only one server that is running locally. So, my configuration is easy

domain_name {
reverse_proxy localhost:port
}

You can configure more with your existing Nginx sites-enabled reference.

Happy SSLing.

If you like the blog or want to comment, kindly reach out to psrdotcom@gmail.com

Indian Passport renewal process and documents

2025-05-13T21:12:00.004+05:30

Hi all,

Here is the updated process for renewing a passport for an adult and a child on the same day and time.

Appointment

Visit the India Passport Seva website
Click on "Register" if you don't have an account.
Click on "Login" if you already have an account.
After successful login, navigate to "Services".
Click on "Fresh Passport/Re-Issue of Passport"
Enter your existing passport number to pre-fill the data.
If it's a fresh passport or you want to manually enter the details, click on the "Skip for Now" link.
Choose the Passport Office
You should see the form below
In the case of "Re-issue of Passport", you will have options to change/modify details in existing passport.
Check the appropriate items
When you check the "Change in Existing Personal Particulars", you will have options to update the following details.
After selecting the "Type of Application" and "Type of Passport Booklet"
Click on "Save and Next".
Post that you will be navigated tothe next section as mentioned in the flow below.
Fill in the relevant details and submit the form.
After submitting the form, you will be able to upload the relevant documents that are available in the DigiLocker.
Select the center and date that you want to visit.
Note: It did not help me to smooth the process even after uploading the documents.

Visiting Center

Take all hard copies, Originals, and Xerox (2 sets)

Application form
Aadhaar Card (Full length)
Existing passport (Front 2 and back 2 Pages) Xerox (no print out with 100% page fill)

In case of a spouse's addition

Marriage certificate original

For the kid application

Fill in "Annexure D"
Date of Birth Certificate

Counters

A Counter: Verification of the documents, scanning the documents, and taking a photo.
B Counter: Cross verification of the A counter form and documents.
C Counter: Originals will be verified.

Police Verification (Will be indicated in the status of the application after the center visit)

In a couple of days, the police will call and make sure you are available upon the visit at the address submitted in the passport application.
Submitted the application form that has been finalized during the center visit.
Original documents (Old passport(s) and address proof).
Details of the neighbour's & physical presence with a signature.
Applicant's signature and thumb along with a passport-size photo that will be stuck to the police filled application.

Please provide your feedback and comments on this blog or email me on psrdotcom@gmail.com

Create static website using ChatGPT Website Generator Plugin

2024-11-27T19:45:00.002+05:30

Hi Everyone,

Here we are where ChatGPT is gathering the required services under one roof.

Click on "Explore GPTs"

Search for "Website Generator"

Prompt the website with the name and major product/service offerings.

It will redirect to the B12 domain with a template. You can update each section with the B12 editor.

For reference, you can visit my website https://psr-and-apps.b12sites.com/index#home

Feel free to send your comments and opinions to psrdotcom@gmail.com

Write Blog Posts using AI Tools

2024-10-28T11:03:00.001+05:30

Hi all,

When writing my blog post, I thought of using AI tools.

Here is the result of my previous blog post content using the AI tool Copy.ai

Title suggestions by tool

1. Version Confusion Begone! Untangling the Web of Package.json Symbols 2. Tildes and Carets and Stars, Oh My! Demystifying npm Version Ranges 3. Semantic Versioning 101: A Beginner's Guide to Package.json Syntax

Meta Description

Struggling with semantic versioning in package.json? This post explains ^, ~, and other symbols. Learn best practices to avoid breaking changes.

Understanding Semantic Versioning

Semantic versioning is a standardized way of versioning software releases using a three-part numbering system: MAJOR.MINOR.PATCH. This system helps developers communicate the scope of changes and ensure compatibility between different versions of a software package.

The MAJOR version is incremented when incompatible API changes are introduced. This means that if you update the MAJOR version, there may be breaking changes that require modifications to the code consuming the package.

The MINOR version is incremented when new backward-compatible functionality is added. Existing code should continue to work as expected with a MINOR version update.

The PATCH version is incremented for backward-compatible bug fixes. These updates should not introduce new features or break existing functionality.

Semantic versioning is crucial for managing dependencies in software projects because it provides a clear and consistent way to communicate the level of changes in each release. By adhering to this versioning scheme, developers can make informed decisions about when to update dependencies and ensure their applications remain stable and compatible with the latest package versions.

The Caret Symbol (^) in Versioning

The caret symbol (^) in semantic versioning is used to specify a range of compatible versions for a dependency. It allows for updates to the minor and patch versions, but not the major version. This means that if your package depends on a library with version 3.4.1, specifying ^3.4.1 in your package.json would allow updates up to version 3.x.x, but not 4.0.0 or higher.

For example, if you have a dependency with version ^3.4.1, it can be updated to any version between 3.4.1 and 3.9.9, including 3.5.0, 3.6.2, or 3.9.0, but not 4.0.0 or higher. This is because the caret symbol only allows updates within the same major version, as major version changes often introduce breaking changes.

The caret symbol is particularly useful when you want to benefit from bug fixes and performance improvements in minor and patch releases, but you don't want to risk introducing breaking changes from a major version update. It provides a balance between staying up-to-date with non-breaking changes and maintaining stability in your application.

However, it's important to note that the behavior of the caret symbol is different when the major version is 0. For example, ^0.3.1 would allow updates up to 0.9.9, but not 1.0.0 or higher. This is because the 0.x.x version range is considered a special case in semantic versioning, indicating a project in the initial development phase, where breaking changes are expected.

Tilde (~) vs Caret (^) Versions

The tilde (~) and caret (^) symbols in front of version numbers are used to specify the range of compatible versions that can be installed for a package. While both symbols allow for updates within certain bounds, they differ in their level of flexibility.

The tilde (~) is more restrictive and only permits updates to the patch and minor versions. For example, ~1.2.3 would allow updates from 1.2.3 to 1.2.9, but not to 1.3.0. This approach is suitable when you want to receive bug fixes and backwards-compatible features, but avoid breaking changes that could potentially introduce compatibility issues.

On the other hand, the caret (^) is more flexible and allows updates to both minor and patch versions. For instance, ^1.2.3 would permit updates from 1.2.3 to 1.9.0, but not to 2.0.0. This approach is recommended when you want to benefit from new features and improvements while still avoiding major version changes that could break your application.

When deciding which symbol to use, consider the trade-off between stability and staying up-to-date. If you prioritize stability and want to minimize the risk of introducing breaking changes, the tilde (~) is a safer choice. However, if you want to take advantage of new features and improvements more readily, the caret (^) may be a better option, as long as you are prepared to handle potential compatibility issues that could arise from minor version updates.

Versions Starting with Zero

When a version number starts with zero (e.g., 0.1.2), it is considered a special case in semantic versioning. Versions with a leading zero indicate that the software is still in the initial development phase and not yet ready for production use. The rules for how the caret symbol (^) is interpreted differ for these versions.

With versions starting with zero, the caret (^) will only allow updates that do not modify the left-most non-zero digit. For example, if you have a dependency specified as ^0.1.2, it will accept any version up to 0.2.0, but not 0.3.0 or higher. This behavior is more restrictive than the standard caret behavior for versions without a leading zero.

The rationale behind this cautious approach is to prevent breaking changes from being introduced during the initial development phase, where the public API is still unstable and subject to significant modifications.

It's essential to be aware of this special handling of versions starting with zero when using the caret symbol (^). If you intend to allow more flexibility in updates, you may need to consider using the tilde (~) or explicitly specifying the desired version range.

Checking Compatibility with Semver Ranges

One of the best ways to understand and work with semantic versioning ranges is to use the semver.npmjs.com tool. This online tool allows you to input a version range and see which versions satisfy that range.

For example, let's say you want to check which versions are compatible with the range ^4.2.3. You can input this into the tool, and it will show you all the versions that fall within that range, such as:

4.2.3
4.2.4
4.3.0
4.3.1
...

But it will exclude versions that would represent a major breaking change, like 5.0.0.

You can also use the tool to test more complex ranges, like ^4.2.3 || ^5.0.0. This will show you all versions compatible with either the 4.x or 5.x release lines.

The semver.npmjs.com tool is invaluable for understanding how different version constraints work and what versions they will allow. It can help you avoid accidentally introducing breaking changes and can make it easier to manage dependencies across different parts of your codebase or project.

Real-world Examples

In the Node.js ecosystem, semantic versioning is widely adopted for managing dependencies in projects. For example, when you run npm install react, you'll notice the package.json file includes a line like "react": "^16.13.1". The caret symbol here means that future updates to the React library that are compatible (i.e., without breaking changes) will be allowed up to the next major version (17.0.0).

Similarly, in the Ruby world, the popular Rails framework follows semantic versioning. If you specify a dependency like gem 'rails', '~> 6.0.0' in your Gemfile, it will allow patch and minor updates to Rails 6.0.x but not updates to 7.0.0 or higher, thanks to the tilde symbol.

Front-end developers working with WordPress plugins or themes often rely on semantic versioning as well. A dependency like "bootstrap": "^4.5.3" in the package.json file ensures that the project can receive compatible updates to Bootstrap 4.x without inadvertently upgrading to a major version 5.0.0, which may introduce breaking changes.

The popularity of semantic versioning has led to the creation of tools like the npm semver calculator, which allows developers to input version constraints and test different scenarios. This helps clarify which updates would be allowed or disallowed based on the specified semantic versioning range.

Importance of Semantic Versioning

Adopting semantic versioning practices in software development projects offers numerous benefits and advantages. By following a standardized convention for versioning, developers can effectively communicate the extent of changes introduced in each release, ensuring compatibility and minimizing the risk of breaking existing functionality.

One of the primary advantages of semantic versioning is improved maintainability and compatibility. When versions are incremented according to the defined rules, developers can easily understand the potential impact of upgrading to a newer version. This information aids in making informed decisions about whether an upgrade is safe or may introduce breaking changes, thereby reducing the likelihood of introducing bugs or conflicts in the codebase.

Semantic versioning also facilitates better collaboration and coordination within development teams and across projects that rely on external dependencies. By adhering to a consistent versioning scheme, team members can quickly grasp the significance of version changes and plan their development efforts accordingly. This practice becomes increasingly valuable as projects grow in complexity and involve multiple interdependent components.

Furthermore, semantic versioning simplifies the process of managing dependencies and their respective versions. Package managers and build tools can leverage the versioning information to automatically resolve compatible versions, reducing the overhead of manual version management and minimizing the risk of version conflicts.

Overall, embracing semantic versioning conventions promotes code stability, enhances collaboration, improves maintainability, and streamlines the dependency management process. These benefits contribute to more efficient and reliable software development practices, ultimately leading to higher-quality products and a better overall experience for both developers and end-users.

Adopting Semantic Versioning

Adopting semantic versioning in your projects can bring numerous benefits, including better communication, easier maintenance, and smoother upgrades. Here are some tips and best practices to help you adopt and consistently follow semantic versioning:

Educate Your Team: Ensure that everyone involved in the project understands the principles and conventions of semantic versioning. Provide training or documentation to ensure a shared understanding of how versions should be incremented and what each part of the version number represents.
Define Version Policies: Establish clear policies and guidelines for when to increment each part of the version number (major, minor, or patch). Outline what constitutes a breaking change, a new feature, or a bug fix, and provide examples to ensure consistent application across the team.
Automate Version Bumping: Utilize tools or scripts that automate the process of incrementing version numbers based on the changes made in each release. This can help reduce human errors and ensure consistent versioning practices.
Integrate with CI/CD: Incorporate semantic versioning into your continuous integration and continuous deployment (CI/CD) pipelines. Automate version increments, tagging, and package publishing as part of your release process.
Document Release Notes: Maintain detailed release notes that clearly explain the changes introduced in each version. This documentation helps consumers of your project understand what has changed and plan their upgrades accordingly.
Use Semantic Versioning from the Start: Adopt semantic versioning from the beginning of your project, even if it's still in an early stage. Consistent versioning practices from the outset can prevent future headaches and make it easier to maintain version compatibility.
Review and Audit Regularly: Periodically review your versioning practices and ensure they align with semantic versioning principles. Conduct audits to identify any deviations or inconsistencies and take corrective actions as needed.

By following these best practices, you can effectively adopt and consistently apply semantic versioning in your projects, ensuring better communication, easier maintenance, and smoother upgrades for both your team and the consumers of your project.

Automated Version Management

Manually managing versions and updates across multiple dependencies can quickly become a tedious and error-prone task, especially as projects grow in complexity. Fortunately, there are various tools and techniques available to automate version management, ensuring that your project stays up-to-date and compatible with the latest package versions.

One popular approach is to integrate automated dependency updates into your project's continuous integration and deployment pipeline. Tools like Renovate, Dependabot, and npm-upgrade can automatically scan your project's dependencies, check for available updates, and create pull requests with the necessary changes. This streamlines the update process, reducing the risk of human error and ensuring that your project benefits from the latest bug fixes, security patches, and feature enhancements.

Another technique is to leverage version pinning or lockfiles, which allow you to specify and lock down the exact versions of your dependencies. This ensures consistent builds across different environments and makes it easier to roll back changes if necessary. Package managers like npm, Yarn, and Bundler support lockfiles, and tools like npm-shrinkwrap and yarn.lock can help you manage and update these files efficiently.

Additionally, some package managers and ecosystems offer built-in support for automated version management. For example, the Rust programming language's package manager, Cargo, automatically updates dependencies to their latest compatible versions when running cargo update. Similarly, the Elixir programming language's mix tool supports the mix deps.unlock command, which updates all dependencies to their latest compatible versions.

By embracing automated version management, you can streamline your development workflow, reduce the risk of version conflicts and compatibility issues, and ensure that your project stays up-to-date with the latest package releases.

Semantic Versioning in Different Ecosystems

Semantic versioning is a widely adopted convention across various programming languages and package ecosystems. However, there can be slight differences or nuances in how it is implemented and interpreted in different contexts.

In the JavaScript ecosystem, with npm as the primary package manager, semantic versioning is strictly followed, and the caret (^) and tilde (~) symbols have specific meanings for managing dependencies. Node.js and its associated tooling heavily rely on semantic versioning for managing packages and their compatibility.

In the Python ecosystem, with pip and conda as popular package managers, semantic versioning is also widely used. However, the interpretation of version ranges can vary slightly. For example, in pip, the caret (^) symbol is not used, and version ranges are specified using different syntax, such as >=1.2.3,<1.3.0.

The Ruby ecosystem, with RubyGems as the package manager, follows semantic versioning conventions closely. The caret (^) and tilde (~) symbols are used similarly to the JavaScript ecosystem for specifying version ranges.

In the Java ecosystem, with Maven and Gradle as popular build tools and package managers, semantic versioning is also widely adopted. However, the syntax for specifying version ranges can be different. For example, in Maven, the caret (^) symbol is not used, and version ranges are specified using different syntax, such as [1.2.3,1.3.0).

The .NET ecosystem, with NuGet as the package manager, also embraces semantic versioning. The caret (^) and tilde (~) symbols are used similarly to the JavaScript ecosystem for specifying version ranges.

It's important to note that while the core principles of semantic versioning are consistent across ecosystems, the specific syntax and implementation details can vary. Developers should refer to the documentation and best practices of their respective programming language and package manager to ensure they are correctly managing dependencies and versioning their projects.

Understanding Python Dependency Versioning Symbols

2024-10-28T10:56:00.005+05:30

Hi all,

It's been so confusing for me when the versions are with different operators.

Introduction: Managing dependencies in Python is crucial for ensuring your project runs smoothly across different environments. Dependencies, or libraries your project relies on, often need specific versions to maintain compatibility. This blog post will walk you through the symbols used in Python versioning and how they work to keep your project stable and functional.

What Are Python Dependencies?

In Python projects, dependencies are essential libraries that your project needs to function. They’re often listed in files like requirements.txt or Pipfile. To keep these dependencies compatible, Python uses specific symbols in versioning to define acceptable package versions. Let's dive into each symbol to see how they impact dependency management.

Key Python Versioning Symbols

Exact Version (==)
- Syntax: package_name==1.0.0
- Meaning: Installs only the specified version. For example, numpy==1.18.5 installs version 1.18.5 of NumPy.
- Best For: Strict requirements when a specific version is necessary for compatibility.
Minimum Version (>=)
- Syntax: package_name>=1.0.0
- Meaning: Installs the specified version or newer. Example: Django>=3.1.0 installs any version of Django from 3.1.0 onward.
- Best For: Ensuring updates without breaking compatibility with older versions.
Maximum Version (<=)
- Syntax: package_name<=1.0.0
- Meaning: Installs only the specified version or older. For example, pandas<=1.2.3 won’t install any version beyond 1.2.3.
- Best For: Avoiding potential incompatibilities with newer versions.
Range of Versions (>= and <=)
- Syntax: package_name>=1.0.0,<=2.0.0
- Meaning: Installs a version within the specified range. Example: Flask>=1.1.0,<=2.0.1 includes versions between 1.1.0 and 2.0.1.
- Best For: Ensuring some flexibility while staying within a compatible version range.
Exclude Specific Versions (!=)
- Syntax: package_name!=1.0.1
- Meaning: Excludes a particular version. Example: requests!=2.21.0 installs any version of requests except 2.21.0.
- Best For: Avoiding known buggy or incompatible versions.
Compatible Release (~= or ^)
- Syntax: package_name~=1.4 or package_name^1.4.0
- Meaning: Installs versions up to, but not including, the next major version. Example: pandas~=1.2.3 includes versions like 1.2.4 but not 1.3.0.
- Best For: Keeping compatibility within a minor version range.
Pre-release and Development Versions (<, >)
- Syntax: package_name<2.0.0
- Meaning: Allows installation of pre-release versions. Example: scipy<2.0.0 might include a development version like 1.5.0.dev.
- Best For: Testing experimental versions, not typically used in production.

Example Usage in Requirements Files

Here are some example scenarios showing how to use these symbols:

Single Requirement: flask==2.0.1 installs only version 2.0.1.
Multiple Requirements: requests>=2.20.0,<3.0.0 installs versions from 2.20.0 up to, but not including, 3.0.0.
Combined Exclusions: scipy>=1.5.2,!=1.6.0,!=1.7.1 installs from 1.5.2 onwards but excludes 1.6.0 and 1.7.1.

Best Practices

Avoid Exact Versioning (==) in Libraries: Using == restricts flexibility for future projects, so avoid it in libraries that might be used elsewhere.
Use Compatible Release (~=) in Production: This symbol allows updates while maintaining compatibility.
Test Development Versions Carefully: Isolate pre-release versions in a separate virtual environment for testing purposes.
Regularly Update Dependencies: Keeping dependencies up to date helps with security and performance. Use pip commands to check for updates.

References

Conclusion

Understanding Python dependency versioning symbols can be the difference between a stable environment and one filled with compatibility issues. Following these guidelines will help you create reliable, well-maintained Python environments.

Online free website tools to separate song audio music background and vocals or voice

2024-09-23T21:43:00.003+05:30

Hi all,

There might be several instances in which you might think you want to have only a song background or vocals (voice) to try your remix skills.

Here are the online tools

Procedure

In both applications, you need to upload the song.
Once it's uploaded after processing, you will get 2 music files.
You can play, and once you are happy with the result, you can download it to the local system.

Feel free to drop your comments and feedback to psrdotcom@gmail.com

Github pages not deploying of a static website

2024-09-05T16:00:00.000+05:30

Hello all,

It's been a long time since I have posted a blog.

But I am trying to come up with the passion of rewriting the blogs.

Here are the recent issues and solutions that I have faced.

Problem

I have my website https://pillisureshraju.in/ hosted on GitHub using GitHub Pages.

I have recently updated one of the pages https://pillisureshraju.in/cv but the GitHub deployment is not triggered.

I have searched and configured the GitHub with the environment and selected the branch for auto-deployment.

Environment

Solution

Update index.html and commit to GitHub with a PR to master.

Finally, I am able to see that the deployment is auto-triggered, and the website is live now.

Feel free to reach out on psrdotcom@gmail.com or leave a comment on this blog.

Change default directory for Windows command prompt and Powershell when running with admin privileges

2023-05-23T14:46:00.004+05:30

Hi all,

It's been a while since I posted things.

Here is my previous post where the non-admin user changes the default directory for the command prompt and PowerShell.

https://psrdotcom.blogspot.com/2022/03/change-default-directory-of-windows.html

But in this post, I will be explaining about running the command prompt / powershell with admin rights and setting the default directory. Because, when you are running with admin privileges, it by default goes to the SYSTEM32 folder of Windows.

Environment

I use the command prompt and PowerShell, which are pinned to the taskbar of Windows.

Run the application with the admin rights

Right-click on the application icon -> click on Properties
Go to the "Compatibility" tab
Check "Run this program as administrator"

Run the shortcut with the admin rights

Right-click on the shortcut icon -> click on Properties
Go to the "Shortcut" tab
Click on the "Advanced" button
Check "Run this program as administrator"

Change the command prompt default directory

We need to have a .bat file with the following content

@echo off
cd <default_directory>

Now use the .bat file in the shortcut properties

Right-click on the shortcut icon -> click on Properties
Go to the "Shortcut" tab
In the "Target" field append the below text

/k "batfile_dirpath\batfile.bat"

Change the PowerShell default directory

Right-click on the shortcut icon -> click on Properties
Go to the "Shortcut" tab
In the "Target" field append the below context after powershell.exe

-NoExit -command "& {Set-Location <default_directory>}"

Click on "OK"

Hope, this helps you to reduce the frequent directory changes in the command prompt and PowerShell.

Feel free to provide your valuable feedback and comments to psrdotcom@gmail.com

Configure a API Backend Server with custom domain on Amazon Web Services (AWS) EC2 Ubuntu with NGINX and Certbot SSL

2022-06-11T02:04:00.010+05:30

Hi all,

Build your own API backend server on AWS free-tier with SSL.

The below steps with reference links will provide detailed information of each step.

AWS account - Free-tier
Create EC2 Ubuntu
Connect to Ubuntu from your local using SSH/Putty
Install NodeJS

Open terminal
curl -fsSL http://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt update
sudo apt install nodejs //installs latest LTS nodejs

Create a sample node server
Install and configure node server process manager

sudo npm install -g pm2@latest
Navigate to nodejs server folder
pm2 start <filename>
pm2 startup systemd
pm2 save
pm2 list // List all the nodejs apps with status
pm2 stop/restart/start app_name/id // Actions of nodejs servers

Install Nginx
Configure your domain DNS records to map to AWS EC2 public/elastic IP address
Secure Nginx with SSL certs

Hope the above information is useful to set up the environment and play with your backend server.

Feel free to send your feedback and comments to psrdotcom@gmail.com

Generate Free SSL HTTPS Certificates with 90 days validity using letsencrypt

2022-06-09T01:08:00.002+05:30

Hi all,

As discussed in my earlier blog, Generate Free SSL Certificate using ZeroSSL where the limitation of one free certificate on ZeroSSL can be eliminated using Get HTTPS for free!

This process includes the following prerequisites and procedures.

Note: This process is not for beginners or production usage scenarios. Use this process if you are knowledgeable about certificate generation.

Prerequisites

OpenSSL command line
[Li]nix / Mac OS

Procedure

Open the URL https://gethttpsforfree.com
It has 5 steps

Account Info
Certificate Signing Request
Sign API Requests
Verify Ownership
Install Certificate

In each step, some commands or processes need to be followed to get the free SSL certificate.

Account Info

In this step, we will be providing the email and public key.
Keep the generated private key security in your system.

Note: If you are unsure about the public key generation commands, click on the "how do I generate this?" link, which is available over the public key input textbox.

Certificate Signing Request (CSR)

Generate the CSR for the required domains

Note: You can generate the CSR for wildcard certificates and www subdomain with the same command

Try to follow the same format, including the line feeds mentioned below.

#change "/etc/ssl/openssl.cnf" as needed:
    #  Debian: /etc/ssl/openssl.cnf
    #  RHEL and CentOS: /etc/pki/tls/openssl.cnf
    #  Mac OSX: /System/Library/OpenSSL/openssl.cnf

    openssl req -new -sha256 -key domain.key -subj "/" \
      -reqexts SAN -config <(cat /etc/ssl/openssl.cnf \
      <(printf "\n[SAN]\nsubjectAltName=DNS:foo.com,DNS:www.foo.com"))

Sign API Requests

Sign all the requests with the private key

Note: You need to copy the command and execute it on your PC/Mac terminal, and the result needs to be pasted on the web page.

Verify Ownership

In this step, you need to prove your domain ownership
You will be given 3 options

Python server
file-based
DNS record (I've used this option)

Update the DNS records with new TXT entries, and use the online dig tool to make sure the records are visible.
After we verify the availability of the records, you need to click on the respective buttons on the web page.

Repeat the same steps for each domain on CSR (www and any sub-domains).

Install Certificate

You will be able to receive your certificate in "chained.pem" format
Copy and paste the first certificate section (e.g. the first "-----BEGIN CERTIFICATE-----" section) into a text file named "domain.crt".
Copy and paste the second certificate section (e.g. the second "-----BEGIN CERTIFICATE-----" section) into a text file named "intermediate.pem".

Note: Expand the "how do I install this?" link for quick help.

Hope this will help you to generate free SSL for your websites.

Request you to send your valuable feedback and comments to psrdotcom@gmail.com

Publish and Consume NPM Packages using GitHub Package Manager

2022-04-29T14:36:00.004+05:30

Hi folks,

We are used to publishing the npm packages on npmjs.com. Today, I will show how we can publish the npm packages to GitHub and the steps to use those packages.

1. Publishing Packages

Prerequisites

We need to have an account with GitHub

JavaScript native/framework based project with package.json

Add the .npmrc file to your project with the following syntax. Change the OWNER value to your GitHub account or organization name.

@OWNER:registry=https://npm.pkg.github.com

Publishing Process to GitHub

Create personal access token using the following steps

Login to GitHub
Go to Settings
Navigate to "Developer Settings" -> "personal access tokens"
Generate token with write:packages access permissions

Open terminal in the project folder
Execute the command to login

npm login --scope=@OWNER --registry=https://npm.pkg.github.com

When prompted,

Username: GitHub username
Password: Personal access token
Public e-mail: Your email address

Enter the following command to publish the package

npm publish

2. Consume/Installing the packages

Prerequisites

We need to have an account with GitHub

Installation

Add the .npmrc file to your project with the following syntax. Change the OWNER value to your GitHub author or organization name.

@OWNER:registry=https://npm.pkg.github.com

Enter the full name @OWNER/package-name-version in dependencies in package.json

Install the dependencies

npm install

Note: If the organization is asking for authorization of personal access token, then you need to authorize from the personal access token section against the token for the respective organization.

Hope you will make use of GitHub for publishing the packages and consuming them with ease.

Request you to send your feedback and comments to psrdotcom@gmail.com

Change default directory of Windows command prompt and Windows PowerShell

2022-03-14T18:39:00.001+05:30

Hi all,

Today I will explain the steps to change the default directory for Windows command prompt and Windows PowerShell.

The default directory for both the command prompt and PowerShell is the "system32" folder of the OS installed directory (By default: "C:\windows\system32").

Day in - Day out, we will open the terminals (command prompt / PowerShell) and navigate the source directory. It sometimes irritates and wastes lots of time.

I have come across this situation and want to avoid re-entry the change directory command.

Environment,

I use the command prompt and PowerShell, which are pinned to the taskbar of Windows.

Change default directory of Windows Command Prompt

Right-click on the taskbar pinned Command Prompt icon
Right-click on the "Command Prompt" menu
Select the "Properties" item
Under the "Shortcut" tab, you will find the "Start in:" label
In the respective text box, enter the path you want to navigate by default.
For example, "C:\Projects".

Change default directory of Windows PowerShell

Open the PowerShell with administrator privileges
Create a profile by using the following steps

New-item -type file -force $Profile

This will create a file "Microsoft.PowerShell_profile.ps1" in the current user documents PowerShell folder.

Syntax

C:\Users\<UserName>\Documents\WindowsPowerShell

Example

C:\Users\PSR\Documents\WindowsPowerShell

Edit file

notepad.exe $Profile

Change the default directory

Syntax

Set-Location <Directory Path>

Example

Set-Location C:\Projects

Clear-Host # To clear the PowerShell screen

Save and close the file
In the PowerShell window, enter the following command to change the profile

. $Profile

It immediately changes from the current directory to the updated default directory.
Close the PowerShell and try to open the PowerShell again to see the change in the directory.

Hope the above information is helpful to you reduce the change directories in day-to-day life.

Send me your valuable feedback to psrdotcom@gmail.com.

Git remove a specific commit(s) from history

2022-03-10T19:40:00.005+05:30

Hi all,

This blog post will let you know about the process of removing the git commit from git history.

Sample Git log

> git log

38384b3 initial commit

f96751b UI changes

2154131 file added

bf9b9c1 Logic corrections

3e75ab7 Bug fix -> (HEAD)

Use case

Remove the commit "file added"

Procedure

Rebase in interaction mode one commit above which we want to remove.

> git rebase -i f96751b

All the commits up to the specified commit will be listed in an order with the prefix "pick". Along with commit messages, the useful commands are available like below.

pick = use commit
reword = use commit, but edit the commit message
edit = use commit, but stop for amending
squash = use commit, but meld into previous commit
fixup = like "squash", but discard this commit's log message
exec = run command (the rest of the line) using shell
drop = remove commit

Delete the unwanted commits from the file

Press 'd' twice to delete line (in case of vi editor)

Save and quit the editor

esc -> :wq (in case of vi editor)

If there are any merge conflicts, resolve it and perform rebase continue

> git rebase --continue

Once all the merges are completed, perform the push operation

> git push --force-with-lease origin

Hope this helps you make sure, you have clean git history.

Feel free to send your suggestions and comments to psrdotcom@gmail.com

Ubuntu - update NPM and NodeJS

2022-02-02T20:09:00.004+05:30

Hi folks,

Some people often confuses with NPM update vs Node.js update.

Let me clarify that, NPM (Node Package Manager) is a CLI (Command Line Interface) to manage the JS (JavaScript) packages from https://www.npmjs.com/ or any other external package managers like GitHub.

Node.js is a FrontEnd JavaScript Framework like Vue.js, AngularJS which helps to build the scalable network applications. Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine.

NVM (Node Version Manager) and n are command line utilities to manage and switch between Node.js versions.

When you are installed for the first time, you will be installing Node.js from https://nodejs.org/en/download/ which also installs NPM CLI utility.

But when upgrading the NPM or Node.js, it's a different story.

Update NPM

npm install -g npm

Update Node.js with Node version manager (n)

Install the n

sudo npm install -g n

Update the Node.js to stable version

sudo n stable

As of now, the stable version is 16.3.2 which includes NPM 8.1.2

Update the Node.js to current version

sudo n current

As of now, the current version is 17.4.0 with NPM 8.3.1

Check the versions

NPM

npm --version

Node.js

node --version

Hope this helps you to understand the NPM and Node.js difference along with update of individual components.

Send your comments and feedback to psrdotcom@gmail.com

Yono SBI - Scan QR and contactless ATM cash withdrawal

2022-01-29T23:36:00.003+05:30

Hi folks,

I had seen something, I want to do and I have done PoC sometime back. Which is contactless ATM cash withdrawal from SBI Yono Mobile app.

Procedure

Visit the SBI ATM which supports QR Scan option on KIOSK ATM screen
Select the QR based Contactless Withdrawal option on the touch screen
Open the Yono Mobile app which is already registered with your SBI account and have enough funds to withdraw
On mobile app, select "QR Cash Withdrawal" option
Scan the ATM displayed QR from the Yono mobile app
Select the amount to withdraw on ATM machine
Enter the PIN or OTP when prompted
Money from ATM will be dispensed
This is almost contactless except, you need to touch the ATM screen twice to select the QR option and to select amount.

This way, we can have less touch points to stay safe and secure way to withdraw your money.

Hope you will use this option to withdraw money from an SBI ATM.

Send your valuable feedback and comments to psrdotcom@gmail.com

Calculate the private key of RSA algorithm

2022-01-29T23:23:00.001+05:30

Hi folks,

Today we are going to see how we can calculate the private key of RSA.

Inputs

Random prime numbers p and q

Public key (n, e)

Procedure

1. Compute n (Random modulus)

n = p * q

2. Compute e (Derived Number)

e = (p - 1) * (q - 1)

3. Form the public key

GCD(pubkey, e) should be 1
pubkey = 1 mod e

4. Private key

prikey = (1 + k * e) / pubkey

0 < k < e - Iterate until we get a number without fraction

Real example

Inputs

p = 7, q = 17, pubkey = 11

1. n = 7 * 17 = 119

2. e = (7-1) * (17-1) = 96

3. pubkey = 11

GCD (11, 96) = 1

4. prikey computation

k=0, (1 + 0 * 96) / 11 = 0.09

k=1, (1 + 1 * 96) / 11 = 8.81

k=2, (1 + 2 * 96) / 11 = 17.5

k=3, (1 + 3 * 96) / 11 = 26.27

k=4, (1 + 4 * 96) / 11 = 35

prikey = 35

Hoping that this blog will be useful in understanding the RSA private key computation.

Send your valuable feedback and comments to psrdotcom@gmail.com

Fixing the Log4j2 vulnerability in spring boot application

2021-12-14T22:09:00.002+05:30

Hi all,

Software Industry was in a shock with the log4j2 zero day exploit.

Exploited area

The Apache Log4j2 version ( >=2.0 to <=2.14.1 ) is exploitable due to an attacker controlled LDAP and JNDI endpoints.

Appendix

LDAP (Light Weight Directory Protocol) is an industry standard protocol to access directory services.

JNDI (Java Naming and Directory Interface) is a Java API for a directory service that allows Java software clients to discover and look up data and resources via a name.

Find more information about the vulnerability from NVD website link.

https://nvd.nist.gov/vuln/detail/CVE-2021-44228

NVD (National Vulnerability Database) is maintained by National Institute of Standards and Technology (NIST), An official part of United States of America (USA) government's Department of Commerce.

Fix the vulnerability

Even in the latest spring boot package uses the vulnerable 2.14.1 log4j2 version.
So, we need to explicitly add the specific version in the properties as below
In pom.xml file, creating <properties> tag if not exists and add the attribute log4j2.version with version 2.16.0 (latest)

<properties>
<log4j2.version>2.16.0</log4j2.version>
</properties>

To check the version applied to the project, run the following command

mvn dependency:tree | grep "log4j"

The result should look like below

[INFO] | | | +- org.apache.logging.log4j:log4j-to-slf4j:jar:2.16.0:compile
[INFO] | | | | \- org.apache.logging.log4j:log4j-api:jar:2.16.0:compile

The similar type of vulnerability fixes available for other project builds.

Hope you will find the above information useful and fix the issue immediately to keep the servers safe from attacks.

Send your valuable feedback and comments to psrdotcom@gmail.com

BitBucket to GitHub Repo Migration including history

2021-11-26T18:55:00.010+05:30

Hi all,

In this blog, we are going to achieve how we can move/copy the bitbucket repo to GitHub.

Checkout BitBucket Repo

git clone https://USER@bitbucket.org/USER/PROJECT.git

Add GitHub repo as upstream

cd project-folder
git remote add upstream https://github.com:USER/PROJECT.git
Note: To get the already assigned upstreams, use the below command
git remote -v

Push the branch(es)

git push upstream master
git push --tags upstream

On push unsuccessful, try the below to have same history

git checkout upstreambranch  
git branch main upstreambranch -f    
git checkout main  
git push origin main -f

Add redirect URL

git remote set-url origin git@github.com:USER/PROJECT.git

Clean up the BitBucket (old) repo [Optional]

Verify the content carefully on the GitHub repo

Go to BitBucket account
Navigate to the respective repository
Click Settings -> Delete repository

Hope this helps you to organize the repositories as per your choice to serve the best way for dev and ops.

Please send your feedback and comments to psrdotcom@gmail.com

Flutter Local (Inbuilt) Authentication usage

2021-11-26T15:40:00.000+05:30

Hi folks,

Today I will explain the process of using local (in-built) authentication usage in Flutter.

Pre-requisites

1. pubspeck.yaml update

dependencies:
local_auth: ^0.6.2+3

2. Install the packages from command line

$ flutter pub get

Note: In Visual Studio Code or Android Studio automatically by saving the pubspec.yaml file packages will get updated

Usage

1. Import the package in the respective dart file (say main.dart)

import 'package:local_auth/local_auth.dart';

Troubleshooting

1. I/flutter : PlatformException(no_fragment_activity, local_auth plugin requires activity to be a FragmentActivity., null)

Open /android/app/src/main/kotlin/../MainActivity.kt
Update the file with following content

package com.[your.package]

import androidx.annotation.NonNull;
import io.flutter.embedding.android.FlutterFragmentActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugins.GeneratedPluginRegistrant

class MainActivity: FlutterFragmentActivity() {
override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
GeneratedPluginRegistrant.registerWith(flutterEngine);
}
}

Please send your feedback and comments to psrdotcom@gmail.com

Extend Ubuntu VM hard disk space/size

2021-11-17T22:41:00.002+05:30

Hi all,

Today I will explain about the process to extend and existing disk space in Ubuntu VM.

Environment

VMWare
Ubuntu

Context

Increase hard disk space more than initially configured for the Ubuntu VM.

Reason

VM hard disk might running out of space.

Procedure

Make sure we have shutdown the Ubuntu VM
Increase the hard disk size

Make sure it's in the allowed range

Start the VM
Open the Disks application in Ubuntu

In below example we are extending it by additional 3GB
Select the Extended Partition block
Click Settings (Gear) icon
Choose Resize option
Use the increment (+) icon or scroll bar to increase the partition size
Click on Resize button
Enter credentials when prompted
By now, the extended partition will be increased
Time to select the file system, where exactly our data is getting stored
We will repeat the process of resizing like earlier
Using scrollbar increase the disk size
Click on the Resize button
The harddisk size is been reflected.

Hurray !! You have increased your hard disk size to store more data on the Ubuntu VM.

The same process can be used for normal Ubuntu OS also.

Please send your comments and feedback to psrdotcom@gmail.com

Convert PEM to PFX/PKCS12(.p12) using OpenSSL

2021-10-07T18:00:00.004+05:30

Hi folks,

To keep it simple with a single command to convert the .PEM format file to .p12/.pfx we can use the below information.

$ openssl pkcs12 -export -in domain.pem -out domain.p12

It will ask you to enter the export password (twice for confirmation).

It's up to you to choose to enter the password or keep it empty (just press enter) based on the use case what you have.

Hope this helps you to convert the certificate format and use in your application or server.

Request to send your comments and feedback to psrdotcom@gmail.com

Generate Free SSL Certificate using ZeroSSL

2021-06-10T21:25:00.005+05:30

Hi all,

Today I am going to explain the process of generating free SSL certificate using ZeroSSL

Pre-requisite

We should have our own domain
We should be able to add/update the DNS settings like A, CNAME, TXT records

Best free SSL providers

As per my research I found the best free SSL (90 days) certificate providers

ZeroSSL
Let's Encrypt

In this blog, i'll explain ZeroSSL process

ZeroSSL Free SSL Certificate

Navigate to https://zerossl.com/
Signup with your email by clicking on "FreeSSL"
After email verification, login to zerossl site
Click on "New Certificate"
Enter your domain name and click on "Next Step"
Default validity is 90 days for free SSL
In the CSR section we have couple of options
Default is Auto-Generate CSR enabled
Disable Auto-Generate CSR - only your zerossl registered email address with default values
Enable Paste Existing CSR - If you have already created a CSR then you can use this option
Finalize your order

Note
ZeroSSL will generate the certificate using signature algorithm SHA-384
In some cases, if SHA-384 based SSL is not valid then we have to mandatory go for alternate "Let's Encrypt". I will explain Let's Encrypt in my next blog.
For every 90 days, we need to renew our certificate in the above mentioned manner.

Download Certificate

Navigate to Certificates section
Go to Issued tab
Click on "Install"
You can select the Default Format dropdown to select specified server or just leave it default.
Download the certificate zip file which will contain

ca_bunder.crt - CA Bundle
certificate.crt - Certificate
private.key - Private Key

Hope, you will be able to make use of this free SSL feature and encrypt your domain traffic.

Please let me know your feedback and suggestions in comments or mail to psrdotcom@gmail.com

Reverse Proxy with IIS ARR (Application Request Routing) and URL Rewrite features

2021-03-03T17:13:00.074+05:30

Dear folks,

Today I am going to explain how we can use the IIS as reverse proxy to secure, redirect the internal application servers.

IIS ARR 3.0 does provide load balancing, cache, forward and reverse proxy features.

This blog will cover the usage of reverse proxy.

Agenda

Secure/Hide the internal servers from public internet requests

Environment Setup

DMZ server with IIS ARR and URL Rewrite
Internal servers which are accessible to DMZ

Pre-requisites

Make sure the IIS is installed on the server
ARR (Application Request Routing)
URL Rewrite

Procedure

Install the pre-requisites
Create InBound and OutBound rules to configure as reverse-proxy
Edit/Create the web.config based on your requirement
Public facing IP - 123.10.1.12
Internal IP - 10.1.1.192

Use case 1

Redirect URLs with 80 port to internal application server on 8001

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<rewrite>

       <rules>
   <rule name="ReverseProxyInboundRule1" stopProcessing="true">
   <match url="(.*)" />

</conditions>

   <action type="Redirect" url="{C:1}://10.1.1.192/{R:1}" />
   </rule>
     </rules>

</rule>

</preCondition>

</preConditions>

</outboundRules>

</rewrite>

</system.webServer>

</configuration>

Use case 2

Redirect URLs with 9001 port to internal application server on 8081 with JSON response

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<rewrite>
<rules>

   <rule name="ReverseProxyInboundRule_Port_JSON" stopProcessing="true">
    <match url="(.*)" />
      <conditions logicalGrouping="MatchAll">
                <add input="{CACHE_URL}" pattern="^(https?)://" />
    <add input="{SERVER_PORT}" pattern="9001" />

   </conditions>
    <action type="Redirect" url="http://10.1.1.192:8081/{R:1}" />
   </rule>
   </rules>

</rule>

</preCondition>

</preConditions>

</outboundRules>

</rewrite>

</system.webServer>

</configuration>

One can make use of the conditions and redirect accordingly

url

use the regular expression to identify the part of the URL to process further

conditions

Use conditions with attributes to distinguish the URL

action

redirect, rewrite, abort with specific URL with arguments

Hope this helps organization to configure and secure the servers

Request you to send your valuable feedback and comments to psrdotcom@gmail.com

Windows Batch File - Embed Image (Base64 Encoded) in HTML Code

2021-01-27T16:01:00.001+05:30

Hi folks,

Today I am going to explain how we can add an image to the HTML code in without copying the images in relative path folder.

Procedure

Prefix file contents.

<img src="data:image/png;base64,

Batch file contents.

https://gist.github.com/psrdotcom/ce1593f170fe931f9840b4a0f3eae89f

Suffix file contents.

" alt="PSR" />

Download the batch file.
Open command prompt in Windows.
Navigate to the batch file contained folder.
Execute the batch file image file name as parameter.

> Image2Base64ImgTag.bat PSRImage.jpeg

You should see a file "imageTag.html".
Open the file to see image in a browser.
Open the file with notepad to see the image converted to base64 with proper HTML Image tag.

Hope this helps you to reduce lot of efforts in maintaining the image files/folders.

Send your feedback and comments to psrdotcom@gmail.com