DEV Community: Shubham Srivastava

🚀🚀🚀Implementing Redis Functionalities in Node.js Applications 📦

Shubham Srivastava — Thu, 07 Mar 2024 10:50:35 +0000

Introduction

This documentation outlines the process of implementing caching using Redis in a Node.js Express application. Caching data with Redis helps reduce response times and server load by:

Storing frequently accessed data in memory
Optimizing data retrieval by avoiding repetitive requests to external sources

Prerequisites

Node.js installed on your machine
Basic understanding of JavaScript and Express.js

Redis Docker Installation

To set up Redis using Docker, follow these steps:

Download and Install Docker:
- Visit the official Docker website.
- Download Docker for your operating system and follow the installation instructions provided.
Run Redis Container: Execute the following command in your terminal to fetch Redis in a Docker container:
```
docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
```
This command pulls the latest Redis image from Docker Hub and runs it in a detached mode (-d). It also names the container as redis-stack, maps the container's port 6379 to the host port 6379 (for Redis), and maps port 8001 to the RedisInsight UI for monitoring Redis data.

Verify Installation:

Check if the Redis container is running by executing:

docker ps

Access RedisInsight by visiting http://localhost:8001 in your web browser. You should see the RedisInsight dashboard.
Connect to the Redis server using the default connection settings (localhost:6379). Here's a visual guide on how to connect:

After verifying that the Redis container is running and accessing RedisInsight, proceed with the following steps to interact with Redis:

a. Run docker ps to check the container IDs.

b. Run the following command to access the Redis container shell (replace <container_id> with the actual container ID):

   docker exec -it <container_id> bash

c. Once inside the container, run the Redis CLI by executing:

   redis-cli

You should now be connected to the Redis server and able to interact with it using the Redis CLI.

Installation

Ensure Redis server is installed and running. Additionally, install required dependencies for your Express application:

npm install express axios ioredis

Basic Setup

Begin by setting up a basic Express application that listens on a specific port:

const express = require("express");
const axios = require("axios");
const app = express();

app.get("/", async (req, res) => {
    const { data } = await axios.get(
      "https://jsonplaceholder.typicode.com/photos"
    );
    return res.json(data);
});

const port = 9000;
app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Problem Statement

Fetching data from external APIs directly may result in slow response times due to network latency and server load,here as you can see it took 364 millisecond to fetch the data.

Solution

Implement caching using Redis to store fetched data temporarily and serve it from the cache for subsequent requests, thereby reducing response times.

Certainly! Here's the updated documentation with the added points:

Implementation Steps

Initialize Redis Client First, create a Redis client to interact with the Redis server. Create a file named client.js and add the following code:

   const { Redis } = require("ioredis");
   const client = new Redis();
   module.exports = client;

Implement Caching Logic Modify your route handler to utilize the Redis client for caching. Update your server.js file with the following code:

   const express = require("express");
   const axios = require("axios");
   const client = require("./client");
   const app = express();

   app.get("/", async (req, res) => {
     const cacheValue = await client.get("to-dos");
     if (cacheValue) {
       console.log("Cached value");
       return res.json(JSON.parse(cacheValue));
     }

     const { data } = await axios.get(
       "https://jsonplaceholder.typicode.com/photos"
     );
     await client.set("to-dos", JSON.stringify(data));
     await client.expire("to-dos", 30);
     return res.json(data);
   });

   const port = 9000;
   app.listen(port, () => {
     console.log(`Server is running on port ${port}`);
   });

Observation of Data Fetching Time
After implementing the caching mechanism, you may notice that the initial data fetching time is higher as it involves fetching data from the external API. However, upon subsequent requests, the data fetching time significantly reduces to approximately 37 milliseconds due to the cached data being served from Redis. This demonstrates the effectiveness of caching in reducing response times and improving overall performance.
Expiration and Renewal
Note that the cached data expires after 30 seconds (await client.expire("to-dos", 30)). Upon expiration, the next request will trigger a fresh data fetch from the external API, refreshing the cache with updated data. This ensures that users receive the most up-to-date information while still benefiting from reduced response times during the cache lifespan.

Conclusion

By implementing caching with Redis in your Express application, you can significantly improve performance by reducing response times and server load. Caching commonly accessed data helps minimize latency and enhances the overall user experience, especially for frequently accessed resources.

##Redis Rapid Reference: Mastering All Commands with PowerShell 🚀💡✨🔮

Shubham Srivastava — Thu, 07 Mar 2024 09:28:28 +0000

Redis Documentation

Welcome to the Redis documentation! Redis is an open-source, in-memory data structure store used as a database, cache, and message broker. It supports various data structures such as:

Strings
Hashes
Lists
Sets
Sorted sets
Bitmaps
Hyperloglogs
Geospatial indexes with radius queries

In this documentation, we'll cover basic commands and functionalities of Redis using the provided PowerShell commands. 🚀💡

Getting Started

First, make sure you have Docker installed on your system to run Redis in a containerized environment.

Install Docker

Follow the instructions on the official Docker website to install Docker on your system: https://docs.docker.com/get-docker/

Introduction to Redis 🌟
SET and GET Commands 🔧
SETNX Command 🛡️
MSET and MGET Commands 🚀
LPUSH and LPOP Commands 🔄
SADD Command ➕
ZADD and ZRANGE Commands 📊
HSET Command 🏷️
PUBLISH Command 📢
SUBSCRIBE Command 📡

Introduction to Redis

Redis is a powerful, open-source, in-memory data structure store known for its performance and versatility. It supports various data structures like strings, hashes, lists, sets, and more, making it ideal for caching, real-time analytics, messaging queues, and much more.

SET and GET Commands

SET: Set a key to hold a string value.

  127.0.0.1:6379> SET name shubham
  OK

GET: Get the value of a key.

  127.0.0.1:6379> GET name
  "shubham"

SETNX Command

SETNX: Set the value of a key, only if the key does not exist.

  127.0.0.1:6379> SETNX user:4 Ayush NX
  OK

MSET and MGET Commands

MSET: Set multiple keys to multiple values in a single atomic operation.
MGET: Retrieve the values of multiple keys.

  127.0.0.1:6379> MSET id:1 "hey" id:2 "hello"
  OK
  127.0.0.1:6379> MGET id:1 id:2
  1) "hey"
  2) "hello"

LPUSH and LPOP Commands

LPUSH: Add one or more values to the beginning of a list.
LPOP: Remove and return the first element of a list.

  127.0.0.1:6379> LPUSH messages hey
  (integer) 1
  127.0.0.1:6379> LPOP messages
  "hey"

SADD Command

SADD: Add one or more members to a set.

  127.0.0.1:6379> SADD ip 1
  (integer) 1

ZADD and ZRANGE Commands

ZADD: Add one or more members to a sorted set.
ZRANGE: Return a range of members in a sorted set.

  127.0.0.1:6379> ZADD no 1 shubham
  (integer) 1
  127.0.0.1:6379> ZRANGE no 0 -1
  1) "shubham"

HSET Command

HSET: Set fields in a hash stored at a specified key.

  127.0.0.1:6379> HSET bike:1 model Deimos brand Ergonom type 'Enduro bikes' price 4972
  (integer) 4

PUBLISH Command

PUBLISH: Publish a message to channels.

  127.0.0.1:6379> PUBLISH notifications hey
  (integer) 1

SUBSCRIBE Command

SUBSCRIBE: Subscribe to channels.

  127.0.0.1:6379> SUBSCRIBE notifications
  1) "subscribe"
  2) "notifications"
  3) (integer) 1

Congratulations! You have successfully learned some basic Redis commands and functionalities. Redis offers a wide range of features for managing and manipulating data efficiently. Explore further to unlock the full potential of Redis in your applications.

🚀 Happy coding with Redis! 🎉

DevOps on AWS - Quick Start Guide🚀

Shubham Srivastava — Fri, 16 Feb 2024 19:33:46 +0000

Welcome to the world of DevOps on Amazon Web Services (AWS)! This guide will walk you through the general desciption of how AWS services are commonly used in DevOps practices.

Introduction
Key AWS Services
- EC2 (Elastic Compute Cloud)
- VPC (Virtual Private Cloud)
- EBS (Elastic Block Store)
- S3 (Simple Storage Service)
- IAM (Identity and Access Management)
- CloudWatch
- Lambda
- AWS Code Services
- AWS Config
- Billing / Costing
- AWS KMS (Key Management Service)
- CloudTrail
- Amazon EKS (Elastic Kubernetes Service)
- ELK (Elasticsearch, Logstash, Kibana)

Introduction

DevOps practices play a crucial role in ensuring seamless collaboration between development and operations teams. AWS provides a comprehensive suite of services tailored to meet the demands of modern DevOps workflows. This guide aims to familiarize you with these AWS services and their relevance to DevOps.

Key AWS Services

EC2 (Elastic Compute Cloud)

EC2 offers resizable compute capacity in the cloud.
Launch virtual servers (instances) tailored to your needs.

VPC (Virtual Private Cloud)

Create isolated virtual networks with customizable IP ranges.
Define subnets, routing tables, and network gateways.

EBS (Elastic Block Store)

Persistent block-level storage volumes for EC2 instances.
Choose from various volume types to suit your requirements.

S3 (Simple Storage Service)

Object storage for storing and retrieving data.
Highly scalable, durable, and secure.

IAM (Identity and Access Management)

Manage access to AWS resources securely.
Create users, groups, and roles with fine-grained permissions.

CloudWatch

Monitor AWS resources and applications.
Collect metrics, monitor logs, and set alarms.

Lambda

Run code without provisioning or managing servers.
Support for multiple programming languages.

AWS Code Services

CI/CD pipeline automation with CodePipeline.
Code compilation and testing with CodeBuild.
Automated deployment with CodeDeploy.

AWS Config

Detailed inventory of AWS resources and configurations.
Continuous monitoring for compliance and auditing.

Billing / Costing

Tools for managing and optimizing costs.
Analyze spending and set budgets.

AWS KMS (Key Management Service)

Create and control cryptographic keys for encryption.
Integrate with other AWS services for data security.

CloudTrail

Record API activities for audit and compliance.
Store logs for analysis and troubleshooting.

Amazon EKS (Elastic Kubernetes Service)

Managed Kubernetes service for containerized applications.
Simplifies deployment, management, and scaling.

ELK (Elasticsearch, Logstash, Kibana)

Open-source stack for log management and analytics.
Indexing, searching, visualization, and analysis of logs.

🛠️🔍

Advance Shell Scripting (1-100)🚀

Shubham Srivastava — Tue, 13 Feb 2024 21:09:02 +0000

Introduction

This documentation provides an overview and examples of various commands and constructs commonly used in Unix/Linux environments for managing processes, manipulating data, and handling conditions.

Commands

`df`

The df command is used to display disk space usage on Unix/Linux systems.
Example:

df

`nproc`

The nproc command prints the number of processing units available to the current process.
Example:

  nproc

`top`

The top command displays real-time information about running processes, system load, and CPU usage.
Example:

top

`ps`

The ps command is used to display information about processes.
Example:

  ps -ef

`grep`

The grep command is used to search for specific patterns within files or output.
Example:

  grep "amazon" /path/to/file

`curl`

The curl command is used to transfer data to or from a server.
Example:

  curl https://example.com

`find`

The find command is used to search for files or directories in a directory hierarchy.
Example:

  find / -name "filename"

Special Commands and Constructs

`sudo`

The sudo command is used to execute commands with elevated privileges.
Example:

  sudo find / -name "filename"

`set`

The set command is used to set shell options.
Example:

  set -e # exit the script when error
  set -o # debug mode
  set -x # debug mode

shell Script :

Certainly! Below are examples demonstrating the usage of set -e, set -x, and set -o.

Example 1: `set -e` (Exit on Error)

#!/bin/bash

# Enable exit on error
set -e

# Command that might fail
ls /nonexistent_directory

# This line won't be executed if the previous command fails
echo "This won't be printed"

In this example, if the ls /nonexistent_directory command fails (since the directory doesn't exist), the script will terminate immediately due to set -e, preventing the subsequent echo command from executing.

Example 2: `set -x` (Debug Mode)

#!/bin/bash

# Enable debug mode
set -x

# Commands to be debugged
echo "Debug mode enabled"
ls -l /etc/passwd
echo "Debug mode disabled"

When this script runs, each command will be printed to the terminal before it is executed, allowing the user to see the commands being run. This is useful for troubleshooting and understanding the flow of execution.

Example 3: `set -o` (Options)

#!/bin/bash

# Enable shell options
set -o nounset # Treat unset variables as errors
set -o errexit # Equivalent to set -e, exit on error

# Undefined variable, will trigger an error
echo $undefined_variable

# This line won't be executed due to errexit option
echo "This won't be printed"

In this example, set -o nounset ensures that using undefined variables will result in an error. Additionally, set -o errexit is equivalent to set -e, causing the script to exit immediately if any command fails.

`if else`

Conditional statements in Unix/Linux are implemented using the if else construct.
Example:

  if [expression]; then
      command1
      command2
  else
      command3
  fi

Advanced Usage

`curl` and `grep`

Combining curl and grep can be useful to filter specific content from web responses.
Example:

  curl https://example.com | grep "Error"

Pipeline Usage

Unix/Linux commands can be chained together using pipes (|) for more complex operations.
Example:

  ./tst.sh | grep "1"

Conclusion

This documentation provides a brief overview and examples of common Unix/Linux commands, special constructs, and their usage in various scenarios. Experimenting with these commands and constructs will help users become proficient in Unix/Linux system administration and scripting.

# Comprehensive Guide to Shell Scripting (0-1)🚀

Shubham Srivastava — Sun, 21 Jan 2024 20:10:29 +0000

Introduction

Welcome to the exciting world of shell scripting! This comprehensive guide will take you from the fundamentals to advanced concepts, helping you automate tasks on Linux environments using shell scripts. 🐚

Creating and Viewing Files
Understanding Commands
Executing Shell Scripts
Managing Permissions
Useful Commands
Example: Basic Shell Script
Shell Scripting Roles

Creating and Viewing Files

To create a file, use the touch command: touch filename.
Shell scripts typically have the extension .sh.
Use ls to list files and directories.
ls -ltr sorts files by modification time.

Understanding Commands

Use man <command> to get a manual about a command.
Editing files: Use vi to open a file, i to insert, and :wq! to save and exit.
The first line in a shell script should contain the shebang (#!/bin/bash).

Executing Shell Scripts

To execute a shell script: sh filename.sh or ./filename.sh.
Permissions: Use chmod to grant permissions. Example: chmod 777 filename.sh.
Permissions include read (4), write (2), and execute (1).

Managing Permissions

chmod 444 filename gives read access only.
Security: Use chmod with root, group, and user access.

Useful Commands

history: View executed commands.
pwd: Know the current directory.
mkdir: Create a directory.
cd: Change directory.

Example: Basic Shell Script

#!/bin/bash

# Creating a folder
mkdir user 

# Creating 2 files
cd user 
touch firstfile secondfile

Shell Scripting Roles

Shell scripting serves three main roles:

Infrastructure Management
Code Management
Configuration Management

User-Friendly Example

Now, let's walk through an example using the username "user":

List files in the current directory:

   user@hostname:~/path/to/directory$ ls

Create and open a shell script file named shellscript.sh:

   user@hostname:~/path/to/directory$ vim shellscript.sh

List files again to confirm the creation of the script:

   user@hostname:~/path/to/directory$ ls
   shellscript.sh  otherfile

View the contents of the shell script:

   user@hostname:~/path/to/directory$ cat shellscript.sh
   #!/bin/bash

   # Create a folder
   mkdir user 

   # Create 2 files
   cd user 
   touch firstfile secondfile

Attempt to execute the script (permission denied):

   user@hostname:~/path/to/directory$ ./shellscript.sh
   bash: ./shellscript.sh: Permission denied

Grant execute permission to the script:

   user@hostname:~/path/to/directory$ chmod 777 shellscript.sh

Execute the script successfully:

   user@hostname:~/path/to/directory$ ./shellscript.sh

List files to verify changes:

   user@hostname:~/path/to/directory$ ls
   shellscript.sh  user  otherfile

Navigate to the 'user' directory:

   user@hostname:~/path/to/directory$ cd user

List files in the 'user' directory:

user@hostname:~/path/to/directory/user$ ls
firstfile  secondfile

Attempt to execute the script inside the 'user' directory (file not found):

user@hostname:~/path/to/directory/user$ ./shellscript.sh
bash: ./shellscript.sh: No such file or directory

Navigate back to the parent directory:

user@hostname:~/path/to/directory/user$ cd ..

Attempt to execute the script again (folder already exists):

user@hostname:~/path/to/directory$ ./shellscript.sh
mkdir: cannot create directory ‘user’: File exists

Advance shell scripting ➡️

Node.js Application Deployment on AWS Documentation 🚀

Shubham Srivastava — Thu, 18 Jan 2024 07:09:20 +0000

Introduction

This comprehensive guide walks you through the step-by-step process of deploying a Node.js application on AWS (Amazon Web Services). Follow these instructions to successfully set up and deploy your project.

Step 1: Clone the Repository

Begin by cloning the project repository to your local system using the following command:

git clone https://github.com/verma-kunal/AWS-Session.git

Step 2: Testing the Project Locally

Set up the necessary environment variables in the .env file:

DOMAIN=""
PORT=3000
STATIC_DIR="./client"
PUBLISHABLE_KEY=""
SECRET_KEY=""

Initialize and start the project:

npm install
npm run start

Step 3: Set Up an AWS EC2 Instance

Create an IAM User:
- Generate an IAM user with Password Access and Admin Permissions.
EC2 Instance Setup:
- Log in to your AWS Console and create an EC2 instance.
- Choose Ubuntu as the OS image and select the t2.micro instance type.
- Create a new key pair and download the .pem file.
Connecting to the Instance Using SSH:
- Locate your .pem file and run the following commands:
```
 chmod 400 "Keyvalue.pem"
 ssh -i instance.pem ubuntu@<IP_ADDRESS>
```
Result: ubuntu@ip-<IP_ADDRESS>:~$

Congratulations! Your AWS instance is now successfully set up locally.

Step 4: Configuring Ubuntu on Remote VM

Update outdated packages and dependencies:

sudo apt update

Install Git, Node.js, and npm following the guides by DigitalOcean.

Step 5: Deploying the Project on AWS

Clone the project in the remote VM:

git clone https://github.com/verma-kunal/AWS-Session.git

Create a .env file and set up environment variables using the vi command:

DOMAIN="http://localhost:3000"
PORT=3000
STATIC_DIR="./client"
PUBLISHABLE_KEY="your_publishable_key"
SECRET_KEY="your_secret_key"

Set up an Elastic IP Address for your EC2 instance and use it as your DOMAIN.

Initialize and start the project:

npm install
npm run start

Step 6: Configure Inbound Rules

Edit the inbound rules in the security group of your EC2 instance to allow traffic from the specific port.

Access your application at [AWS Public IP]:3000

Congratulations! Your Node.js application is now successfully deployed on AWS. 🎉

Feel free to access it through your configured DOMAIN and explore your deployed project. If you have any further questions or encounter issues, refer to the official AWS documentation or seek assistance from the AWS community. Happy coding! 🚀

Git branching strategy

Shubham Srivastava — Sun, 14 Jan 2024 06:39:22 +0000

Git Documentation 🚀

Introduction on git

Git is a distributed version control system widely used in software development, known for its speed, flexibility, and resilience. It enables efficient collaboration among developers, offering features such as versioning, branching, and merging. Major hosting platforms like GitHub and GitLab leverage Git for collaborative software development.

Key Features

1. Version Control System (VCS) 🔄

A Version Control System helps manage and track changes in source code, documents, or any set of files over time. Git, a powerful VCS, ensures systematic versioning, providing a reliable history of changes.

2. Speed and Efficiency ⚡

Git is renowned for its speed, making it efficient even for large projects. Developers can perform operations quickly, enhancing productivity and enabling a smooth development workflow.

3. Flexibility and Branching 🌳

Git offers flexibility through its branching mechanism, allowing developers to work on different aspects of a project simultaneously. This feature promotes parallel development, making it easier to manage and merge changes without conflicts.

4. Resilience and Reliability 🛡️

Designed for resilience, Git ensures the integrity of version history, recovering from various issues. It provides a robust and dependable platform for version control.

Types of Git Branching Strategy

a. Gitflow Branching Strategy 🌿

Gitflow is a popular branching strategy utilizing two main branches: master and develop. The master branch holds production-ready code, while the develop branch contains the latest development code. Feature branches stem from the develop branch, and upon completion, they are merged back into it. When the develop branch is ready for release, it merges into the master branch, creating a new release.

Gitflow is robust but complex, ideal for large projects with extended release cycles, demanding strict discipline in feature branch creation and merging.

b. Feature Branching 🚀

Feature branching is a simple strategy where each new feature is developed on its branch. This approach allows isolated development and testing, facilitating easy rollback if needed. Feature branches originate from the master branch and merge back when the feature is complete.

Feature branching suits smaller projects or teams seeking a straightforward strategy. However, it may become unwieldy for larger projects with numerous developers and features.

c. Release Branching 🚢

Release branching involves creating a new branch for each project release. This strategy allows final testing and bug fixing on the release branch before merging into the master branch for production.

Release branching is suitable for projects with short release cycles or specific testing requirements for each release. However, managing multiple release branches simultaneously can pose challenges.

d. Hotfix Branching Strategy 🔥

The Hotfix branching strategy within Git is a specialized approach designed to rapidly address critical issues in a production environment. Unlike the feature-driven nature of Gitflow, the Hotfix strategy allows for the swift resolution of urgent bugs without waiting for the regular release cycle.

When a critical issue arises, a Hotfix branch is created directly from the master branch, ensuring a basis on the latest production-ready code. This isolation prevents interference with ongoing development efforts. Developers then focus on efficiently resolving the identified issue on the Hotfix branch.

Once the Hotfix is complete, it undergoes a dual merging process. First, it is merged into the master branch for immediate deployment, rectifying the critical problem in the production environment. Second, the Hotfix branch is merged into the develop branch to ensure the fix becomes part of the ongoing development, incorporating it into future releases.

Deploying an nodejs application on aws ➡️

Shell scripting with Aws

Shubham Srivastava — Fri, 12 Jan 2024 10:27:04 +0000

Introduction

After successfully installing and creating your AWS EC2 instance, let's delve into the world of shell scripting by implementing a popular GitHub API. This script will allow you to view the list of collaborators and remove someone from it, addressing the common issue of revoking permissions when a person leaves an organization or a project.

AWS EC2 Instance Setup

Start by creating an AWS instance using the following image:

Connect your CLI to your EC2 instance and clone the GitHub repository with the following command:

git clone https://github.com/surajvast1/shell-script

GitHub Collaboration Test

Create a GitHub organization and add a collaborator to test your script. Run the following set of commands in your terminal:

cd shell-scripting-projects/github-api
export username="<organization_username>"
export token="<github_access_token>"
./list-users.sh <repo_owner> <repo_name>

For example:

cd shell-scripting-projects/github-api
export username="surajvast1"
export token="ghp_sAJKxxxxxxxxxxxxxxxxxxxxxxxxxx"
./list-users.sh surajvast1 shell-script

jq Information

The script utilizes jq to access only the names of collaborators from the JSON response.

Advanced Scripting with Helper Function

To enhance the shell script, a helper function can be added. Here is an example:

function helper {
  expected_cmd_args=2
  if [ $# -ne $expected_cmd_args ]; then
    echo "Please execute the script with the required cmd and args"
    echo "./list-users.sh <repo_owner> <repo_name>"
  fi
}

This function ensures that the script is executed with the correct number of command-line arguments.
🚀👩‍💻

Git branching strategy ➡️

Getting started with an Amazon Ec2

Shubham Srivastava — Tue, 09 Jan 2024 18:53:47 +0000

Meanwhile, take a look at AWS's free-tier services by visiting: AWS Free Tier.

Hello Readers!let's dive into Amazon's renowned cloud computing service, EC2 (Elastic Cloud Computing), a key player in the AWS cloud computing lineup. EC2 stands out for its widespread use and user-friendly nature, making it accessible for beginners and experts alike.

When it comes to cloud computing, Amazon's AWS is in a league of its own, outshining even Google's Cloud Computing. Here's why AWS, and specifically EC2, is the go-to choice:

Intuitive User Interface: AWS boasts a better and more user-friendly UI/UX, making it a breeze for users to navigate and make the most of its features.
Consistency & Reliability: EC2 offers a reliable and consistent performance, ensuring your applications run smoothly without any glitches.
Flexibility, Scalability, and High Performance: AWS provides the flexibility to scale resources as needed, ensuring top-notch performance to meet varying demands.
Pay-As-You-Go Pricing: The cost-effective pay-as-you-go pricing model means you only pay for the resources you use, making it a financially savvy choice.
Customization Options: EC2 offers a plethora of customization options, allowing you to tailor your computing environment to suit your specific requirements.
Security at the Forefront: Security is a top priority for AWS, ensuring that your data and applications are safeguarded against potential threats.
Rich Learning Resources: AWS provides extensive learning platforms, tutorials, and comprehensive documentation, making it easier for users to grasp and make the most of the services.
Exceptional Customer Care Support: AWS takes customer support seriously, providing unparalleled assistance and guidance to its users. Your satisfaction is their priority.

In summary, EC2 under AWS stands out not just for its technical capabilities but also for its user-focused approach, making it a leading choice in the realm of cloud computing services.

Elastic Cloud Computing (EC2):
About EC2
Setup EC2 Instance
Stepwise installation.
Setup SSH Key
Connect and clone Git repo
install Node.js, NPM modules, and learn how to launch a website.
Conclusion
AWS Elastic Cloud Computing (EC2)

About AWS EC2
Amazon Elastic Compute Cloud (Amazon EC2) provides scalable computing capacity in the Amazon Web Services (AWS) cloud. Using Amazon EC2 eliminates your need to invest in hardware upfront, so you can develop and deploy applications faster. You can use Amazon EC2 to launch as many or as few virtual servers as you need, configure security and networking, and manage storage. Amazon EC2 enables you to scale up or down to handle changes in requirements or spikes in popularity, reducing your need to forecast traffic.
Setup EC2 Instance
Sign up on AWS at https://aws.amazon.com/ and make an account. You will need to enter your billing and credit card information. However, you'll be charged few dollars or less just to get confirm it's a legit account and the deducted amount will get refunded later on.

Note: You should delete instances you no longer need to ignore any additional billing unknowingly.

Find and Select Amazon EC2 from listed products and services.
Click the button: "Launch Instance"

Now, follow to the steps mentioned below to get started and for a successful installation.

Step 1: Choose an Amazon Machine Image (AMI): This is the operating system your virtual machine in the cloud will be. As Ubuntu is popular, open-sourced, easy to use, and included in free tier eligibility.

Step 2: Choose an Instance Type: Leave it at "General purpose t2.micro free tier eligible". Click "Next: Configure Instance Details."

Step 3: Configure Instance Details: Leave the default settings. Click "Next: Add Storage"

Step 4: Add Storage: Leave the default settings. Click "Next: Add Tags"

Step 5: Add Tags: Create a key and value. I named mine "tutorial-key": "tutorial-value"

Step 6: Configure Security Group: Check the radio button labeled "create a new security group" and give it a name and description. Make sure there is an SSH type listed and add HTTP and HTTPS. Click "Review and Launch"

Step 7: Review Instance Launch: Click "Launch" The following window should appear. Select "Create a new key pair" and type in a name. Click "Download." Make sure you save this file!!! Click "launch instance" You should be redirected to a page where you can click "view instances" to see all your instances. Your new EC2 instance should appear and may take a few moments to initialize.

Yaay! You have successfully created a new EC2 instance!

Devops Shell scripting ➡️

Devops learning complete guide(5)

Shubham Srivastava — Tue, 09 Jan 2024 18:34:23 +0000

Creating an id in aws and configuring with cli

Create an aws account->

Connecting to AWS (Amazon Web Services) from a Linux terminal typically involves using the SSH (Secure Shell) protocol. Here are the general steps to connect to an AWS instance from your Linux terminal:

Prerequisites:
AWS Account:

Make sure you have an AWS account and the necessary permissions to access EC2 instances.
Key Pair:

When you launch an EC2 instance, you will need to specify a key pair. Download and save the private key file (.pem) securely on your local machine.

Steps:
Open Terminal:

Open your Linux terminal on your local machine.
Navigate to the Directory:

Move to the directory where you saved your private key file using the cd command.

cd /path/to/your/keypair/

Change Key File Permissions:
Set the correct permissions for your private key file.

chmod 400 your-key-pair.pem

Connect using SSH:

Use the ssh command to connect to your AWS instance. Replace your-instance-ip with the actual public IP address or DNS name of your AWS instance and your-key-pair.pem with the name of your private key file.

ssh -i your-key-pair.pem ec2-user@your-instance-ip

If your instance uses a different username (e.g., ubuntu for Ubuntu instances), replace ec2-user with the appropriate username.

Confirm Connection:
If prompted to confirm the connection, type "yes" and press Enter.
Connected to AWS Instance:

You should now be connected to your AWS instance via the Linux terminal.

Successfully changed
[ec2-user@ip-xxx-xx-xx-xxx ~]$

AWS Ec2

Linux operating system and basic of shell scripting

Shubham Srivastava — Tue, 09 Jan 2024 17:22:19 +0000

Introduction

An operating system (OS) serves as the crucial bridge between your software applications and the underlying hardware of a computer. It manages and facilitates communication between various software programs and the hardware components, ensuring a seamless and efficient computing experience.

Ubuntu vs. Windows

When comparing Ubuntu and Windows, several factors make Ubuntu stand out:

Free and Open Source: Ubuntu is freely available, open-source software. Users can download, use, and modify it without any cost, fostering a collaborative and supportive community.
Security: Ubuntu's Linux-based architecture is inherently more secure than Windows. Its robust security features, combined with regular updates, help protect against vulnerabilities and threats.
Distributions: Ubuntu offers various distributions tailored for different purposes, such as server deployments, desktop use, or specialized applications. This flexibility allows users to choose the version that best fits their needs.
Speed: Ubuntu tends to be faster and more lightweight than Windows, making it a preferred choice for users seeking optimal performance, especially on older hardware.

OS Diagram Model

The OS diagram model encompasses several key components:

Kernel: The core of the operating system that interfaces between software and hardware. It manages device and memory resources, processes, and handles system-related calls.
System Libraries: Collections of pre-compiled routines and functions that facilitate communication between the kernel and software applications.
Compilers: Tools that convert source code into machine-readable code, enabling the execution of user programs.
User Process: The space where user applications and processes run, interacting with the kernel and system libraries.

Fundamentals of Shell Scripting

Shell scripting involves using commands to communicate with the operating system. It is especially valuable in server environments where graphical user interfaces (GUIs) may be impractical. Key points include:

Shell Scripting Definition: The use of commands within a shell to automate tasks and interact with the operating system.
Server Environments: Due to the resource-intensive nature of GUIs, servers often rely on shell scripting for efficiency and resource optimization.
Common Commands:
- cd: Change directory
- pwd: Print working directory
- ls: List files and directories
- mkdir: Create a new directory
- touch: Create an empty file
- vi: Text editor; press i to insert text, :wq! to save, and exit
- cat: Display file content
- cd ..: Move up one directory level
- clear: Clear the terminal screen
- rm: Remove a file
- rm -r: Remove a directory and its contents
System Information:
- df -h: Display disk space usage
- nproc: Show the number of CPUs
- top: Display system information, processes, and resource usage

By understanding these fundamental concepts, users can navigate and interact with the operating system efficiently, automate tasks through shell scripting, and make informed choices when selecting an operating system for their needs.

Getting started with Amazon Ec2 ➡️

"⚡️⚡️⚡️ Cloud Computing 101: A Beginner's Guide to Mastering the Basics 🚀☁️☁️"

Shubham Srivastava — Tue, 09 Jan 2024 09:02:25 +0000

Cloud computing is the on-demand delivery of IT resources over the Internet with pay-as-you-go pricing. Instead of buying, owning, and maintaining physical data centers and servers, you can access technology services, such as computing power, storage, and databases, on an as-needed basis from a cloud provider

Cloud computing can majorly be classified into two main models:

1.Deployment Model
2.Service Model

What is a Cloud Deployment Model?

The cloud deployment model determines how and where your data is stored and who can access it, based on factors like ownership and scale. It outlines the structure of your cloud setup, including server locations and control mechanisms, and clarifies whether you'll receive pre-made services or need to build everything from scratch

Cloud Deployment Models

1. Public Cloud

2. Private Cloud

3. Hybrid Cloud

4. Community Cloud

Public Cloud

A public cloud is a cloud computing model where IT infrastructure like servers, networking, and storage resources are offered as virtual resources accessible over the internet.The name says it all. It is accessible to the public.

A third-party provider maintains the hardware, relevant software, and licenses in a globally distributed network of data centers. You can access exactly what you need on-demand and at any scale from any device of choice.

Advantages of the Public Cloud Model:

Scalability:
- Public clouds offer virtually unlimited scalability.
- Resource usage can be quickly increased or decreased based on demand without capacity concerns.
Cost Efficiency:
- Operates on a pay-as-you-go model, reducing upfront investment in hardware and infrastructure.
- Pay only for the resources utilized, leading to significant cost savings.
Reliability:
- Public cloud providers invest heavily in infrastructure maintenance.
- Multiple data centers worldwide ensure access to the latest hardware and software.
- Third-party providers ensure all upgrades and patches are up-to-date, enhancing reliability.

Examples of public cloud services:

Amazon Web Services (AWS)
Microsoft Azure
Google Cloud Platform (GCP)
IBM Cloud
Oracle Cloud Infrastructure (OCI)

Private Cloud

A private cloud is a cloud computing environment dedicated to a single organization. Any cloud infrastructure has underlying compute resources like CPU and storage that you provision on demand through a self-service portal.In a private cloud, all resources are isolated and in the control of one organization.

The cloud platform is implemented in a cloud-based secure environment that is protected by powerful firewalls and under the supervision of an organization’s IT department.

Advantages of the Private Cloud Model:

Cost Efficiency and Control:
- Companies seeking cost efficiency and greater control over data and resources may find the private cloud more suitable.
Enhanced Security and Flexibility:
- Some organizations believe the private cloud offers benefits such as enhanced security, flexibility, and control.
- They prefer the freedom to make architectural decisions and select hardware and software tailored to their requirements.
- Private cloud adoption may also be driven by the need to meet regulatory compliance for sensitive data.
Data Privacy:
- The private cloud is ideal for storing corporate data, limiting access to authorized personnel only.
Security Measures:
- Segmentation of resources within the same infrastructure enhances access control and security levels.

Examples of private cloud solutions:

VMware vCloud Suite
Microsoft Azure Stack
OpenStack
Cisco UCS Director
HPE Helion CloudSystem

Hybrid Cloud

As the name suggests, a hybrid cloud is a combination of two or more cloud architectures. A hybrid cloud is a mixed computing environment where applications are run using a combination of computing, storage, and services in different environments—public clouds and private clouds, including on-premises data centers or “edge” locations.

A company with critical data will prefer storing on a private cloud, while less sensitive data can be stored on a public cloud. The hybrid cloud is also frequently used for 'cloud bursting'.

Cloud bursting :

In a private cloud architecture, the access point for third-party utilization serves as a gateway to external cloud resources, primarily used for cloud bursting scenarios. During periods of high demand, when the organization's private infrastructure reaches capacity, the access point enables seamless integration with public cloud services. This allows the organization to dynamically extend its computing resources into the public cloud, providing additional capacity to meet workload spikes. By leveraging external resources only when needed, organizations can optimize costs and maintain performance levels while retaining control over sensitive data and critical workloads within their private cloud environment.

Advantages of the Hybrid Cloud Model:

Cost-Effectiveness:
- Hybrid solutions leverage the public cloud primarily for data storage, reducing overall costs compared to purely private cloud setups.
Security:
- Data segmentation enhances security, lowering the risk of data theft from attackers.
Flexibility:
- Higher flexibility allows businesses to design custom solutions tailored precisely to their needs.

Examples of hybrid cloud platforms:

AWS Outposts
Azure Stack
Azure VMware Solution
Google Anthos
Nutanix Cloud Infrastructure
VMware Cloud Foundation

Community Cloud

It allows systems and services to be accessible by a group of organizations. It is a distributed system that is created by integrating the services of different clouds to address the specific needs of a community. The infrastructure of the community could be shared between the organization which has shared concerns or tasks. It is generally managed by a third party or by the combination of one or more organizations in the community.

Advantages of the Community Cloud Model:

Cost Effectiveness:
- Shared infrastructure leads to cost savings for participating organizations.
Shared Resources:
- Allows for efficient resource sharing among multiple organizations, optimizing infrastructure utilization.
Collaboration and Data Sharing:
- Facilitates collaboration and data sharing among community members, promoting synergy and productivity.

Examples of community cloud platforms:

Government Community Cloud (GCC)
Healthcare Community Cloud
Financial Services Community Cloud
Research Community Cloud
Education Community Cloud

Service model ->

DEV Community: Shubham Srivastava

🚀🚀🚀Implementing Redis Functionalities in Node.js Applications 📦

Introduction

Prerequisites

Redis Docker Installation

Installation

Basic Setup

Problem Statement

Solution

Implementation Steps

Conclusion

##Redis Rapid Reference: Mastering All Commands with PowerShell 🚀💡✨🔮

Redis Documentation

Getting Started

Install Docker

Table of Contents

Introduction to Redis

SET and GET Commands

SETNX Command

MSET and MGET Commands

LPUSH and LPOP Commands

SADD Command

ZADD and ZRANGE Commands

HSET Command

PUBLISH Command

SUBSCRIBE Command

DevOps on AWS - Quick Start Guide🚀

Table of Contents

Introduction

Key AWS Services

EC2 (Elastic Compute Cloud)

VPC (Virtual Private Cloud)

EBS (Elastic Block Store)

S3 (Simple Storage Service)

IAM (Identity and Access Management)

CloudWatch

Lambda

AWS Code Services

AWS Config

Billing / Costing

AWS KMS (Key Management Service)

CloudTrail

Amazon EKS (Elastic Kubernetes Service)

ELK (Elasticsearch, Logstash, Kibana)

Advance Shell Scripting (1-100)🚀

Introduction

Commands

df

nproc

top

ps

grep

curl

find

Special Commands and Constructs

sudo

set

Example 1: set -e (Exit on Error)

Example 2: set -x (Debug Mode)

Example 3: set -o (Options)

if else

Advanced Usage

curl and grep

Pipeline Usage

Conclusion

# Comprehensive Guide to Shell Scripting (0-1)🚀

Introduction

Table of Contents

Creating and Viewing Files

Understanding Commands

Executing Shell Scripts

Managing Permissions

Useful Commands

Example: Basic Shell Script

Shell Scripting Roles

User-Friendly Example

Node.js Application Deployment on AWS Documentation 🚀

Introduction

Step 1: Clone the Repository

Step 2: Testing the Project Locally

`df`

`nproc`

`top`

`ps`

`grep`

`curl`

`find`

`sudo`

`set`

Example 1: `set -e` (Exit on Error)

Example 2: `set -x` (Debug Mode)

Example 3: `set -o` (Options)

`if else`

`curl` and `grep`