DEV Community: Nirmalya Mondal

🎉 Hacktoberfest & Durga Puja: A Bengali's October of Celebration 🌸

Nirmalya Mondal — Wed, 16 Oct 2024 12:08:09 +0000

This is a submission for the [2024 Hacktoberfest Writing Challenge](https://dev.to/challenges/hacktoberfest): Contributor Experience

October is my favorite month of the year, and being a Bengali, it’s easy to see why! 🥳 It’s Durga Puja time — the most awaited festival filled with joy, community, and traditions. But now, October brings me another reason to celebrate — Hacktoberfest! 🎊 For me, Hacktoberfest is the festival of open-source, a time when tech enthusiasts like me come together to make a difference.

🎯 Why I Participated

Having joined Hacktoberfest back in 2023, this annual event has become something I eagerly look forward to. It's not just about contributing code but about being part of a global movement! 🌍 Participating allows me to sharpen my skills, give back to the projects I love, and collaborate with talented people from around the world.

💻 Projects I Worked On

In 2024, I completed all four PRs, and I couldn’t be prouder! Here’s a glimpse of what I worked on:

React Projects ⚛️

I’m a big fan of React, and this year I wanted to dive even deeper. I contributed to a variety of projects, adding features, squashing bugs, and improving the UI. It was great knowing that my contributions made some user interfaces faster and more accessible.
Docker Contributions 🐳

As a DevOps enthusiast, Docker has been my go-to tool for managing containers. This year, I focused on optimizing Docker images, enhancing CI/CD workflows, and polishing up Docker-related documentation. It was particularly satisfying to contribute to projects where I could apply both my coding and DevOps expertise.

💡 What I Learned

Every year, Hacktoberfest teaches me something new, and this year was no exception. Here are a few key takeaways:

React Performance: I learned several techniques to optimize React components for better performance, which is crucial for building scalable front-end applications.
Docker Efficiency: My contributions in Docker led me to discover ways to reduce image sizes and improve build speeds — essential skills in DevOps.
Collaboration: Open-source is all about community, and the maintainers I interacted with were incredibly helpful. I improved my communication and collaboration skills by discussing issues, reviewing code, and brainstorming solutions with contributors from around the world. 🌐

🧡 October: A Month of Festivals

For me, October is not just about Durga Puja, but also about Hacktoberfest! The sense of community, excitement, and joy that both bring into my life is unmatched. Just as I eagerly await the beautiful idol of Goddess Durga each year, I now look forward to my contributions being part of a much larger picture in the world of open source. 🚀

🌟 Final Thoughts

Hacktoberfest 2024 was a blast! 🎉 Completing all four PRs this year, especially in React and Docker, gave me a deep sense of accomplishment. Whether it's adding a new feature or improving documentation, every contribution is a small but meaningful step in the open-source journey. 👏

As October comes to an end, I can’t help but look forward to Hacktoberfest 2025. I can’t wait to dive back into the open-source world and make an even bigger impact. Until then, here’s to continuous learning and building — for both Durga Puja and Hacktoberfest! 🛠️🙏

Basic MySQL Queries: A Comprehensive Guide

Nirmalya Mondal — Fri, 23 Aug 2024 18:52:09 +0000

Author: Nirmalya Mondal

Introduction

MySQL is one of the most popular relational database management systems (RDBMS) used for web applications and other data-driven applications. Whether you’re a beginner or someone looking to brush up on your MySQL skills, understanding the basic queries is essential. This blog will walk you through some fundamental MySQL queries that you can use for database operations, table manipulations, and data management.

1. Database Operations

Create Database

To start with, you need a database where you will store your tables and data. Creating a database is straightforward:

CREATE DATABASE my_database;

Select Database

Once you have created the database, use the following query to select it:

USE my_database;

Drop Database

If you need to delete a database, use the following command:

DROP DATABASE my_database;

2. Table Operations

Create Table

Tables are where your data is stored. You can create a table with specific columns as follows:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100),
    age INT
);

Show Tables

To see all the tables in your selected database:

SHOW TABLES;

Describe Table Structure

If you want to know the structure of a table, you can describe it:

DESCRIBE users;

Alter Table

If you need to modify a table by adding or changing columns:

Add a Column

  ALTER TABLE users ADD phone VARCHAR(15);

Modify a Column

  ALTER TABLE users MODIFY age TINYINT;

Drop Table

To delete a table:

DROP TABLE users;

3. Data Operations

Insert Data

To add data to a table:

INSERT INTO users (name, email, age) VALUES ('John Doe', 'john@example.com', 25);

Select Data

Retrieve data from a table:

SELECT name, email FROM users WHERE age > 20;

Select All Data

To retrieve all data from a table:

SELECT * FROM users;

Update Data

To update data in a table:

UPDATE users SET age = 26 WHERE name = 'John Doe';

Delete Data

To remove data from a table:

DELETE FROM users WHERE name = 'John Doe';

4. Conditional Queries

WHERE Clause

Use the WHERE clause to filter records based on specific conditions:

SELECT * FROM users WHERE age > 20;

AND/OR Conditions

Combine multiple conditions using AND or OR:

SELECT * FROM users WHERE age > 20 AND name = 'John Doe';

IN Clause

Select data based on a list of values:

SELECT * FROM users WHERE age IN (20, 25, 30);

BETWEEN Clause

Filter data within a range:

SELECT * FROM users WHERE age BETWEEN 20 AND 30;

LIKE Clause

Search for patterns using the LIKE clause:

SELECT * FROM users WHERE name LIKE 'J%';

IS NULL / IS NOT NULL

Filter records with NULL or NOT NULL values:

SELECT * FROM users WHERE email IS NULL;

5. Aggregate Functions

COUNT

Count the number of rows:

SELECT COUNT(*) FROM users;

SUM

Calculate the sum of a column:

SELECT SUM(age) FROM users;

AVG

Find the average value of a column:

SELECT AVG(age) FROM users;

MAX and MIN

Find the maximum or minimum value of a column:

SELECT MAX(age) FROM users;

SELECT MIN(age) FROM users;

6. Grouping and Sorting

GROUP BY

Group data based on one or more columns:

SELECT age, COUNT(*) FROM users GROUP BY age;

HAVING

Filter grouped data:

SELECT age, COUNT(*) FROM users GROUP BY age HAVING COUNT(*) > 1;

ORDER BY

Sort data in ascending or descending order:

SELECT * FROM users ORDER BY age DESC;

7. Join Operations

Inner Join

Fetch data from multiple tables where the condition is met in both:

SELECT users.name, orders.order_date FROM users
INNER JOIN orders ON users.id = orders.user_id;

Left Join

Fetch data from the left table and matching rows from the right table:

SELECT users.name, orders.order_date FROM users
LEFT JOIN orders ON users.id = orders.user_id;

Right Join

Fetch data from the right table and matching rows from the left table:

SELECT users.name, orders.order_date FROM users
RIGHT JOIN orders ON users.id = orders.user_id;

8. Subqueries

Subquery in WHERE

Use a subquery to filter results:

SELECT name FROM users WHERE id = (SELECT user_id FROM orders WHERE order_id = 1);

Subquery in SELECT

Use a subquery to calculate values:

SELECT name, (SELECT COUNT(*) FROM orders WHERE users.id = orders.user_id) AS order_count
FROM users;

9. Views

Create View

Create a virtual table based on a query:

CREATE VIEW user_orders AS
SELECT users.name, orders.order_date FROM users
INNER JOIN orders ON users.id = orders.user_id;

Drop View

Delete a view:

DROP VIEW user_orders;

10. Indexing

Create Index

Improve query performance by creating an index:

CREATE INDEX idx_name ON users (name);

Drop Index

Remove an index:

DROP INDEX idx_name ON users;

Conclusion

Understanding these basic MySQL queries is essential for anyone working with relational databases. Whether you are managing data, optimizing queries, or ensuring data integrity, these commands form the foundation of your MySQL skills. By mastering them, you'll be well-equipped to handle most database-related tasks with ease.

Scaling Your AWS Infrastructure with Load Balancers, Auto Scaling, and CloudWatch.

Nirmalya Mondal — Mon, 29 Apr 2024 12:49:19 +0000

In the world of cloud computing, scalability and high availability are crucial for ensuring your applications can handle fluctuating traffic demands and remain resilient to failures. Amazon Web Services (AWS) provides a suite of services that work together to achieve these goals, including Elastic Load Balancing, Auto Scaling, and CloudWatch.

Elastic Load Balancing

Elastic Load Balancing (ELB) is a service that automatically distributes incoming traffic across multiple EC2 instances. By distributing the load across a group of instances, ELB enhances the fault tolerance of your applications, ensuring that if one instance fails, traffic is automatically rerouted to the remaining healthy instances.

ELB supports three types of load balancers:

Application Load Balancer: Ideal for load balancing HTTP and HTTPS traffic, it can route traffic based on advanced routing rules, such as URL paths and host-based routing.
Network Load Balancer: Designed for load balancing TCP, UDP, and TLS traffic, it offers exceptional performance and low latency.
Classic Load Balancer: The legacy load balancer that routes traffic based on application or network level information.

Auto Scaling

Auto Scaling is a service that automatically adjusts the number of EC2 instances in your application based on defined conditions, such as CPU utilization, network traffic, or custom metrics. By automatically scaling your resources up or down, Auto Scaling ensures that you have the right amount of compute capacity to handle your application's workload while optimizing costs.

Auto Scaling groups are the core component of Auto Scaling, where you define the desired capacity, minimum and maximum number of instances, and scaling policies. These policies determine when and how instances should be launched or terminated based on the defined metrics.

CloudWatch

CloudWatch is a monitoring and observability service that collects and tracks metrics, logs, and events from your AWS resources and applications. It provides visibility into resource utilization, application performance, and operational health.

In the context of Auto Scaling, CloudWatch plays a crucial role by providing the metrics that trigger scaling events. You can define CloudWatch alarms based on specific metrics, such as CPU utilization or network traffic, and use these alarms to trigger Auto Scaling policies.

Putting it All Together

By combining these services, you can build a highly scalable and resilient infrastructure for your applications:

Deploy your application across multiple EC2 instances in an Auto Scaling group.
Configure an Elastic Load Balancer to distribute traffic across these instances.
Set up CloudWatch alarms to monitor specific metrics, such as CPU utilization or request counts.
Define Auto Scaling policies that scale out (add instances) when the CloudWatch alarms indicate high load, and scale in (remove instances) when the load decreases.

This architecture ensures that your application can handle traffic spikes by automatically launching additional instances, while also reducing costs by terminating unnecessary instances during periods of low demand.

Additionally, CloudWatch can be used to monitor various aspects of your infrastructure, including ELB metrics, Auto Scaling group metrics, and custom application metrics, providing you with comprehensive visibility into your system's performance and health.

By leveraging these powerful AWS services, you can build a highly scalable, fault-tolerant, and cost-effective infrastructure that can adapt to changing demands, ensuring your applications remain available and responsive to your users.

Architecture Diagram

+---------------+
|     Client    |
+---------------+
        |
+---------------+
| Elastic Load  |
|   Balancer    |
+---------------+
        |
+---------------+
|  Auto Scaling |
|     Group     |
+---------------+
|   EC2    |   EC2    |   EC2    |
|Instance  |  Instance |  Instance|
+---------------+---------------+
        |
+---------------+
|   CloudWatch  |
|    Alarms     |
+---------------+
        |
+---------------+
|   Auto Scaling|
|    Policies   |
+---------------+

The architecture diagram illustrates the interactions between the different AWS services:

Clients send requests to the Elastic Load Balancer.
The Elastic Load Balancer distributes incoming traffic across the EC2 instances in the Auto Scaling group.
CloudWatch monitors various metrics from the EC2 instances, such as CPU utilization or request counts.
When CloudWatch alarms are triggered based on the defined thresholds, Auto Scaling policies are invoked.
Auto Scaling policies either launch or terminate EC2 instances within the Auto Scaling group to adjust the capacity based on the current demand.

This continuous cycle of monitoring, scaling, and load balancing ensures that your application can handle varying traffic loads while maintaining high availability and optimizing resource utilization.

Scaling Your AWS Infrastructure with Load Balancers, Auto Scaling, and CloudWatch.

Nirmalya Mondal — Mon, 29 Apr 2024 12:49:13 +0000

Elastic Load Balancing

ELB supports three types of load balancers:

Application Load Balancer: Ideal for load balancing HTTP and HTTPS traffic, it can route traffic based on advanced routing rules, such as URL paths and host-based routing.
Network Load Balancer: Designed for load balancing TCP, UDP, and TLS traffic, it offers exceptional performance and low latency.
Classic Load Balancer: The legacy load balancer that routes traffic based on application or network level information.

Auto Scaling

CloudWatch

Putting it All Together

By combining these services, you can build a highly scalable and resilient infrastructure for your applications:

Deploy your application across multiple EC2 instances in an Auto Scaling group.
Configure an Elastic Load Balancer to distribute traffic across these instances.
Set up CloudWatch alarms to monitor specific metrics, such as CPU utilization or request counts.
Define Auto Scaling policies that scale out (add instances) when the CloudWatch alarms indicate high load, and scale in (remove instances) when the load decreases.

Architecture Diagram

+---------------+
|     Client    |
+---------------+
        |
+---------------+
| Elastic Load  |
|   Balancer    |
+---------------+
        |
+---------------+
|  Auto Scaling |
|     Group     |
+---------------+
|   EC2    |   EC2    |   EC2    |
|Instance  |  Instance |  Instance|
+---------------+---------------+
        |
+---------------+
|   CloudWatch  |
|    Alarms     |
+---------------+
        |
+---------------+
|   Auto Scaling|
|    Policies   |
+---------------+

The architecture diagram illustrates the interactions between the different AWS services:

Clients send requests to the Elastic Load Balancer.
The Elastic Load Balancer distributes incoming traffic across the EC2 instances in the Auto Scaling group.
CloudWatch monitors various metrics from the EC2 instances, such as CPU utilization or request counts.
When CloudWatch alarms are triggered based on the defined thresholds, Auto Scaling policies are invoked.
Auto Scaling policies either launch or terminate EC2 instances within the Auto Scaling group to adjust the capacity based on the current demand.

Mastering Git: Cheatsheets, Commands, and Interview Prep

Nirmalya Mondal — Sat, 27 Apr 2024 06:39:55 +0000

GitHub has become an essential tool for developers worldwide, enabling seamless collaboration, version control, and code management. Whether you're a seasoned developer or just starting, mastering GitHub can give you a significant edge in your career. In this comprehensive blog post, we'll explore GitHub cheatsheets, command descriptions, and provide a curated list of interview questions to help you ace your next GitHub-related interview.

Git vs GitHub

Q. ARE THEY SAME?

A Big NO!
Git and GitHub are different tools with distinct purposes, and it's important not to confuse them.

Git is a distributed version control system that manages and tracks changes in source code during software development. It allows developers to:

Work on the same codebase simultaneously
Track changes and revert to previous versions
Collaborate effectively with team members

GitHub is a web-based hosting service for Git repositories. It provides:

A central repository for storing Git repositories
A user-friendly interface for managing repositories
Tools for collaboration, such as pull requests and issue tracking

In essence, Git is the version control system, while GitHub is the platform for hosting and collaborating on Git repositories.

Git (Version Control System)
- Manages code changes
- Distributed version control

GitHub (Hosting and Collaboration)
- Hosts Git repositories
- Facilitates collaboration
- Pull requests, issue tracking, etc.

Using Git and GitHub together streamlines collaboration, version control, backup, and project management for software development teams.

Git Cheatsheets

Cheatsheets are handy resources that provide a quick reference to commonly used commands and workflows. Here are some essential GitHub cheatsheets to bookmark:

Git Cheat Sheet: This official cheatsheet covers basic Git commands, setup, and configuration.
GitHub Flow Cheat Sheet: A visual guide to the GitHub Flow, a lightweight, branch-based workflow.
Git Cheatsheet from Tower: A comprehensive cheatsheet covering various Git commands and scenarios.

Git Command Descriptions

Understanding GitHub commands is crucial for efficient version control and collaboration. Here's a breakdown of some essential commands:

Command	Description
`git init`	Initializes a new Git repository in the current directory.
`git clone`	Creates a local copy of a remote repository.
`git add`	Stages changes for the next commit.
`git commit`	Records staged changes to the repository.
`git push`	Uploads local commits to a remote repository.
`git pull`	Downloads commits, files, and updates from a remote repository.
`git branch`	Lists, creates, or deletes branches.
`git checkout`	Switches between branches or restores files from a specific commit.
`git merge`	Combines the changes from one branch into another.
`git log`	Shows the commit history for the current branch.
`git stash`	Temporarily stores changes that you don't want to commit immediately.
`git stash pop`	Applies the most recently stashed changes and removes them from the stash.
`git reset`	Undoes changes to the staging area or committed changes.
`git revert`	Reverts a specific commit by creating a new commit that undoes the changes introduced by the specified commit.
`git diff`	Shows the differences between commits, branches, or your working directory and the staging area.
`git status`	Displays the current state of your working directory and staging area, showing which files have been modified, added, or removed.
`git remote`	Manages the remote repository connections.
`git fetch`	Downloads objects and references from a remote repository without merging them into your local repository.
`git rebase`	Applies commits from one branch onto another branch, rewriting the commit history in the process.
`git tag`	Creates, lists, deletes, or verifies tags, which are references used to mark specific points in the commit history.
`git blame`	Shows who made each line change in a file and when the changes were made.
`git cherry-pick`	Applies specific commits from one branch to another branch.
`git clean`	Removes untracked files from the working directory.
`git reflog`	Shows a log of references and the commit history, providing a way to recover lost commits or branches.

Git & GitHub Interview Questions

Preparing for GitHub-related interviews can be daunting, but practicing with relevant questions can boost your confidence and preparedness. Here are some common GitHub interview questions:

1.What is Git, and how is it different from GitHub?

Git is a distributed version control system that allows you to track changes in your code over time. It is a tool for managing and coordinating changes across multiple developers working on the same codebase. GitHub, on the other hand, is a web-based hosting service for Git repositories, providing a platform for collaboration, code review, issue tracking, and project management.

2.Explain the GitHub Flow workflow.

The GitHub Flow is a lightweight, branch-based workflow that integrates seamlessly with GitHub. It involves creating a new branch for each feature or bug fix, making commits to that branch, opening a pull request for code review, and merging the branch into the main branch after the review and approval process.

3.How do you resolve merge conflicts in GitHub?

Merge conflicts occur when two or more branches have made changes to the same lines of code. To resolve a merge conflict, you need to open the conflicted file(s) in a text editor, locate the conflict markers (<<<<<<<, =======, and >>>>>>>), and manually edit the file to keep the desired changes. After resolving the conflicts, you can add the updated files and commit the changes.

4.What is a pull request, and how do you create one?

A pull request is a way to propose and collaborate on changes to a repository. To create a pull request, you first push your changes to a new branch in your forked repository, then navigate to the original repository on GitHub and create a new pull request. This allows other contributors to review your changes, provide feedback, and ultimately merge your branch into the main codebase.

5.How do you revert a commit in GitHub?

To revert a commit in GitHub, you can use the git revert command followed by the commit hash you want to revert. This creates a new commit that undoes the changes introduced by the specified commit. Alternatively, you can use the GitHub interface to revert a commit by navigating to the commit, clicking the "Revert" button, and creating a new pull request with the reverted changes.

6.What are branches in Git, and how do you create and manage them?

Branches in Git represent independent lines of development. They allow you to work on new features, bug fixes, or experiments without affecting the main codebase. To create a new branch, you can use the git branch <branch-name> command, and then switch to that branch with git checkout <branch-name>. Managing branches involves merging changes back into the main branch, deleting obsolete branches, and maintaining a clear branching strategy.

7.How do you fork a repository on GitHub?

Forking a repository on GitHub creates a personal copy of the original repository under your GitHub account. This allows you to freely experiment with changes without affecting the original project. To fork a repository, navigate to the repository on GitHub, click the "Fork" button in the top-right corner, and choose the account where you want to create the fork.

8.What is the difference between git pull and git fetch?

git pull is a combination of git fetch and git merge. It fetches the latest changes from the remote repository and automatically merges them into your local branch. git fetch, on the other hand, only downloads the latest changes from the remote repository without merging them. This allows you to review the changes before merging them into your local branch.

9.How do you squash multiple commits into a single commit in GitHub?

To squash multiple commits into a single commit in GitHub, you can use the interactive rebase feature. First, you need to run git rebase -i HEAD~n, where n is the number of commits you want to squash. In the interactive rebase editor, change the word "pick" to "squash" for the commits you want to combine. After saving and exiting the editor, you'll be prompted to provide a new commit message for the squashed commit.

10.What is a GitHub Action, and how can it be used in a project?

GitHub Actions is a continuous integration and continuous deployment (CI/CD) platform provided by GitHub. It allows you to automate your software development workflows, such as building, testing, and deploying your code. You can define custom workflows using YAML files in your repository, triggered by events like pushes, pull requests, or scheduled tasks. GitHub Actions can be used for tasks like running tests, building and deploying applications, managing releases, and more.

Remember, mastering Git & GitHub is an ongoing process, and regular practice and exposure to real-world scenarios are key to becoming proficient. Stay curious, explore additional resources, and don't hesitate to reach out to the GitHub community for guidance and support.

Happy coding and collaborating!
Nirmalya Mondal

The Definitive Guide to Installing JENKINS on an EC2 Instance.

Nirmalya Mondal — Fri, 15 Mar 2024 22:28:35 +0000

Jenkins is a powerful open-source automation server that facilitates continuous integration and continuous delivery (CI/CD). Installing Jenkins on an EC2 instance is a common choice for those seeking flexibility and scalability. This guide provides a step-by-step process that ensures a reliable installation, suitable for various scenarios.

Prerequisites

Before diving into the installation, ensure that you have the following:

An AWS account with appropriate permissions to create and manage EC2 instances.
Basic knowledge of AWS services and EC2 concepts.
An EC2 instance running a compatible Linux distribution (Ubuntu is recommended).

Step 1: Launch an EC2 Instance

Log in to AWS Console:

Access the AWS Management Console and navigate to the EC2 dashboard.

Launch EC2 Instance:

Click on "Launch Instance" and choose an Amazon Linux 2 AMI or your preferred Linux distribution.

Configure Instance:

Select an instance type based on your requirements.
Configure instance details, add storage, and configure security groups.
Ensure that port 8080 is open in the security group to allow Jenkins access.

Review and Launch:

Review your configuration and launch the instance.
Choose an existing key pair or create a new one to access the instance securely.

Step 2: Connect to the EC2 Instance

Use SSH to connect to your EC2 instance:

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

Step 3: Update the System and Install JAVA

Update the package lists and install necessary dependencies:

sudo apt update 
sudo apt-get install fontconfig openjdk-17-jre

Step 4: Install Jenkins

This is the Debian package repository of Jenkins to automate installation and upgrade. To use this repository, first add the key to your system (for the Weekly Release Line):

sudo wget -O /usr/share/keyrings/jenkins-keyring.asc \
https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

Step 5: Add Jenkins Repository

Then add a Jenkins apt repository entry:

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
    https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
    /etc/apt/sources.list.d/jenkins.list > /dev/null

Step 6: Update Package and Install Jenkins

Update your local package index:

sudo apt-get update
sudo apt-get install jenkins

Step 7: Access Jenkins Web Interface

Open your web browser and navigate to http://your-ec2-instance-ip:8080. Retrieve the initial Jenkins admin password:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins web interface to unlock.

Step 8: Install Recommended Plugins

Choose "Install suggested plugins" to install the default plugins or select specific plugins according to your needs.

Step 9: Create Admin User

After the plugins are installed, create an admin user and set up Jenkins according to your preferences.

Step 10: Start Using Jenkins

You now have Jenkins installed and configured on your EC2 instance. Explore Jenkins, create jobs, and automate your workflows!

Note: For enhanced security, consider configuring HTTPS using a reverse proxy like Nginx or Apache. Always refer to the Jenkins documentation for the latest and most accurate information.

By following these steps, you've established a robust Jenkins installation on your EC2 instance, setting the foundation for efficient CI/CD pipelines.

The Definitive Guide to Installing Jenkins on an EC2 Instance.

Nirmalya Mondal — Sun, 18 Feb 2024 19:14:14 +0000

Prerequisites

Before diving into the installation, ensure that you have the following:

An AWS account with appropriate permissions to create and manage EC2 instances.
Basic knowledge of AWS services and EC2 concepts.
An EC2 instance running a compatible Linux distribution (Ubuntu is recommended).

Step 1: Launch an EC2 Instance

Log in to AWS Console:

Access the AWS Management Console and navigate to the EC2 dashboard.

Launch EC2 Instance:

Click on "Launch Instance" and choose an Amazon Linux 2 AMI or your preferred Linux distribution.

Configure Instance:

Select an instance type based on your requirements.
Configure instance details, add storage, and configure security groups.
Ensure that port 8080 is open in the security group to allow Jenkins access.

Review and Launch:

Review your configuration and launch the instance.
Choose an existing key pair or create a new one to access the instance securely.

Step 2: Connect to the EC2 Instance

Use SSH to connect to your EC2 instance:

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

Step 3: Update the System and Install JAVA

Update the package lists and install necessary dependencies:

sudo apt update 
sudo apt-get install fontconfig openjdk-17-jre

Step 4: Install Jenkins

This is the Debian package repository of Jenkins to automate installation and upgrade. To use this repository, first add the key to your system (for the Weekly Release Line):

sudo wget -O /usr/share/keyrings/jenkins-keyring.asc \
https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

Step 5: Add Jenkins Repository

Then add a Jenkins apt repository entry:

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
    https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
    /etc/apt/sources.list.d/jenkins.list > /dev/null

Step 6: Update Package and Install Jenkins

Update your local package index:

sudo apt-get update
sudo apt-get install jenkins

Step 7: Access Jenkins Web Interface

Open your web browser and navigate to http://your-ec2-instance-ip:8080. Retrieve the initial Jenkins admin password:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins web interface to unlock.

Step 8: Install Recommended Plugins

Choose "Install suggested plugins" to install the default plugins or select specific plugins according to your needs.

Step 9: Create Admin User

After the plugins are installed, create an admin user and set up Jenkins according to your preferences.

Step 10: Start Using Jenkins

You now have Jenkins installed and configured on your EC2 instance. Explore Jenkins, create jobs, and automate your workflows!

Note: For enhanced security, consider configuring HTTPS using a reverse proxy like Nginx or Apache. Always refer to the Jenkins documentation for the latest and most accurate information.

By following these steps, you've established a robust Jenkins installation on your EC2 instance, setting the foundation for efficient CI/CD pipelines.

Folder Structure For E-commerce

Nirmalya Mondal — Sat, 20 Jan 2024 11:16:51 +0000

Create a Folder

**- src
  - components
  - context
  - pages
  - redux
  - firebase**

Step 1 : Create a Navbar Folder

**- components
  - navbar
    - Navbar.jsx**

Step 2 : Create a Footer Folder

**- components
  - footer
    - Footer.jsx**

Step 3 : Create a Layout Folder

**- components
  - layout
    - Layout.jsx**

Layout.jsx

**import React from 'react'
import Footer from '../footer/Footer'
import Navbar from '../navbar/TopNvbar'

function Layout({ children }) {
  return (
    <div>
      <Navbar />
      <div className="content">
        {children}
      </div>
      <Footer />
    </div>
  )
}

export default Layout**

Step 4 : Create a Page

**- pages
  - home
    - Home.jsx
  - allproducts
    - AllProducts.jsx
  - Order
    - Order.jsx
  - cart
    - Cart.jsx
  - admin
    - dashboard
      - Dashboard.jsx
  - nopage
    - NoPage.jsx**

**Home.jsx**

**import React from 'react'

function Home() {
  return (
    <div>Home</div>
  )
}

export default Home**

Step 5 : Import Layout in Home.jsx

**import React from 'react'
import Layout from '../../components/layout/Layout'

function Home() {
  return (
    <Layout>Home</Layout>
  )
}

export default Home**

Step 6 : Create a route of all page

Install React router dom for routing

**npm i react-router-dom**

Define routes in App.jsx

Import BrowserRouter as Router, Route, Routes, from react-router-dom

**import {
  BrowserRouter as Router,
  Route,
  Routes,
} from "react-router-dom";**

Complete Code

**import React from 'react'
import {
  BrowserRouter as Router,
  Route,
  Routes,
} from "react-router-dom";

import Home from './pages/home/Home';
import Order from './pages/order/Order';
import Cart from './pages/cart/Cart';
import Dashboard from './pages/admin/dashboard/Dashboard';
import NoPage from './pages/nopage/NoPage';

function App() {
  return (
    <Router>
      <Routes>
        <Route path="/" element={<Home/>} />
        <Route path="/order" element={<Order/>} />
        <Route path="/cart" element={<Cart/>} />
        <Route path="/dashboard" element={<Dashboard/>} />
        <Route path="/*" element={<NoPage/>} />
      </Routes>
    </Router>
  )
}

export default App**