Forem: Asad

🗃️ MongoDB & Mongo Express – Docker Setup

Asad — Fri, 16 May 2025 01:27:35 +0000

This guide provides a quick and easy way to run MongoDB and Mongo Express using Docker. It includes their purpose, Docker usage, and troubleshooting steps for container management.

📌 Overview

🔹 MongoDB

MongoDB is a popular NoSQL database that stores data in flexible, JSON-like documents. It’s ideal for scalable, high-performance applications where schema flexibility is important.

🔹 Mongo Express

Mongo Express is a lightweight, web-based admin interface for MongoDB. It allows you to:

View and manage databases
Browse collections and documents
Execute queries and CRUD operations
Use a user-friendly web UI to interact with MongoDB

🚀 Getting Started

Ensure Docker is installed and a custom Docker network exists:

docker network create project-network

🐳 Start MongoDB Container

docker run -d --name mongodb \
  --network project-network \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=password \
  -v mongo-data:/data/db \
  mongo:4.4

Explanation:

Uses mongo:4.4 (recommended for CPUs without AVX support)
Stores data in a named volume: mongo-data
Runs on a shared Docker network for Mongo Express to connect

🐳 Start Mongo Express Container

docker run -d --name mongo-express \
  --network project-network \
  -e ME_CONFIG_MONGODB_ADMINUSERNAME=admin \
  -e ME_CONFIG_MONGODB_ADMINPASSWORD=password \
  -e ME_CONFIG_MONGODB_SERVER=mongodb \
  -e ME_CONFIG_BASICAUTH_USERNAME=admin \
  -e ME_CONFIG_BASICAUTH_PASSWORD=pass123 \
  -p 8083:8081 \
  mongo-express:latest

Access the Web UI: http://localhost:8083

Login Credentials:

Username: admin
Password: pass123

🛑 Troubleshooting: Force Stop Unresponsive Containers

If docker stop fails, you can manually stop the container using the container’s process ID:

1. Get the container's PID

docker inspect --format '{{.State.Pid}}' <container_name>

2. Kill the process

sudo kill -9 <PID>

3. Remove the container

docker rm <container_name>

(Optional) Restart Docker daemon

sudo systemctl restart docker

standard Docker commands to stop containers and clean up your environment:

🛑 Stop Docker Containers

Stop a specific container:

docker stop <container_name_or_id>

Stop all running containers:

docker stop $(docker ps -q)

🧼 Remove Docker Containers

Remove a specific container:

docker rm <container_name_or_id>

Remove all stopped containers:

docker container prune

Remove all containers (running or stopped):

docker rm -f $(docker ps -aq)

🗑️ Remove Docker Images

Remove a specific image:

docker rmi <image_id>

Remove all unused images:

docker image prune

Remove all images:

docker rmi -f $(docker images -aq)

🧹 Remove Docker Volumes (Optional)

Remove unused volumes:

docker volume prune

Remove all volumes:

docker volume rm $(docker volume ls -q)

🔄 Restart Docker (if needed)

sudo systemctl restart docker

🧹 Cleanup Docker Resources (Extreme Measures)

To remove all containers and images:

docker stop $(docker ps -aq)
docker rm $(docker ps -aq)
docker rmi -f $(docker images -aq)

🐳 What is Docker? A Beginner-Friendly Breakdown

Asad — Wed, 14 May 2025 01:30:08 +0000

If you're new to containerization or just want a clear understanding of Docker, you're in the right place. In this post, we’ll walk through the what, why, and how of Docker in a simple, no-fluff format.

📦 What is Docker?

Docker is an open-source platform that makes it easier to build, ship, and run applications using containers.

A container is a lightweight, portable package that includes everything your app needs to run: source code, libraries, dependencies, and environment variables — all bundled together.

Think of it like a “super zip file” that runs your code the same way on any machine.

🤔 Why Was Docker Needed?

Before Docker, developers faced the classic:

"It works on my machine" 😤

Apps would break when moving between dev, test, and prod environments due to OS differences, missing libraries, or conflicting dependencies.

Developers either:

Struggled with heavyweight virtual machines, or

Wrote complex setup scripts to recreate environments.

Docker came in to streamline and standardize how we build and deploy apps — from laptops to cloud servers.

🛠️ What Problem Does Docker Solve?

Docker solves several real-world challenges for developers and ops teams:

✅ Environment consistency — no more "works on my machine"

✅ Faster development cycles — containers start in milliseconds

✅ Easy testing & deployment — replicate production locally

✅ Lightweight & efficient — uses less memory than VMs

✅ Portability — run containers anywhere Docker is installed

🔧 What is the Docker Daemon?

The Docker Daemon (dockerd) is the engine that powers Docker.

It runs in the background and:

Listens for Docker CLI/API commands

Builds images

Starts/stops containers

Manages networks and volumes

The CLI (docker) talks to the Daemon via a REST API.

💡 You can think of the daemon as the brain, and the CLI as your hands.

📄 What is a Dockerfile?

A Dockerfile is a set of instructions used to build a Docker image.

It defines:

The base image

What files to copy

Dependencies to install

Commands to run

Example Dockerfile for a Node.js app:

Dockerfile

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

This creates a container that installs dependencies and starts your app with npm start.

🖼️ What is a Docker Image?
A Docker image is a snapshot of your application environment.

It’s:

Built from a Dockerfile

Immutable (read-only)

Portable

Once you have an image, you can run it as a container:

docker run my-app-image

Images can be pushed to registries (like Docker Hub) and pulled by anyone, anywhere.

👤 What Permissions Are Needed to Run Docker as "ubuntu" User?

By default, running Docker commands requires sudo:

sudo docker ps

To run Docker as a non-root user (e.g., ubuntu), add the user to the docker group:

sudo usermod -aG docker ubuntu

Then log out and back in to apply the group change.

⚠️ Warning: The docker group has root-equivalent access. Use with caution.

🚀 Wrapping Up

Docker has become a must-have tool for modern developers. Whether you're building microservices, deploying to the cloud, or just trying to eliminate “it works on my machine” bugs — Docker makes your workflow more predictable, portable, and powerful.

Have questions or want to dive deeper into Docker Compose, networking, or volumes? Let me know in the comments! 👇

Follow me for more practical DevOps and backend dev content! 🙌

SSH Key Generating for Git hub Process

Asad — Sat, 22 Mar 2025 13:00:29 +0000

What is SSH

SSH is also known as Secure Shell Protocol, which allows sys admins or users a secure way to access their systems over the unsecured network. You need ad public key and a private key to connect to the security systems.

The public is a key that will be used to decrypt the private key and usually gets saved in the secure credentialing manager on the user's system.

The private key is an encrypted key that the users will have it saved somewhere safe on their computers.

The process demonstrated here is done on Linux, if you follow along you wont fail.

Navigate to cd ~/.ssh
ssh-keygen -o -t key(RSA) -C "your GitHub email address"
If it asks you for a location just hit enter or return because by default ssh will look for the key here. /home/devbox/.ssh
The location of the ssh key cat id_key(rsa).pub
Copy and paste it into the git hub setting > ssh key.

]]>

User/Group Management and Permissions/Ownership in Linux

Asad — Sat, 01 Mar 2025 05:00:48 +0000

Linux, as a multi-user operating system, requires effective user and group management to maintain system security and control access to resources. This document outlines key concepts and practices in user/group management and file permissions/ownership.

User Management

Types of Users

Root User : Superuser with unrestricted system access. Home directory: /root.
Regular Users : Non-privileged users with home directories in /home/username.

Creating Users

bashsudo useradd johnsudo passwd john

User Configuration Files

/etc/passwd: User account information
/etc/shadow: Encrypted passwords and account expiration data
/etc/group: Group information

Group Management

Groups facilitate managing permissions for multiple users simultaneously.

Creating Groups and Adding Users

bashsudo groupadd developerssudo usermod -aG developers john

Key Management Commands

useradd: Add new user
passwd: Set/change user password
usermod: Modify user account
groupadd: Add new group
groups: Display user's group memberships
deluser: Delete user
delgroup: Delete group

Permissions and Ownership

Linux uses a permission model to control file and directory access.

File Ownership

Owner: User who owns the file
Group: Group that owns the file

Change ownership:

bashsudo chown user:group filename

File Permissions

Permissions are represented as:

text-rwxr-xr--

First character: File type
Next three: Owner permissions
Following three: Group permissions
Last three: Others' permissions

Permissions include:

r: Read
w: Write
x: Execute

Changing File Permissions

Using chmod command:

Symbolic mode:

bashchmod u+rwx filenamechmod g-w filenamechmod o=rx filename

Numeric mode:

bashchmod 755 filenamechmod 644 filename

Practical Scenarios

Creating a New User and Assigning to a Group
Changing File Ownership and Permissions

Comprehensive Example

bashsudo useradd alicesudo passwd alicesudo groupadd engineerssudo usermod -aG engineers alicegroups alicetouch project.txtsudo chown alice:engineers project.txtchmod 664 project.txtls -l project.txt

This comprehensive guide provides a solid foundation for managing users, groups, and file permissions in Linux environments, essential for maintaining system security and access control.

10 Corporate Real-Time Shell Scripts

Asad — Fri, 28 Feb 2025 17:18:49 +0000

Backup Script Script

SOURCE="/home/ubuntu/Test01"DESTINATION="/home/ubuntu/Test02/"DATE=$(date +%Y-%m-%d_%H-%M-%S)# Create backup directory and copy filesmkdir -p $DESTINATION/$DATEcp -r $SOURCE $DESTINATION/$DATEecho "Backup completed on $DATE"

Explanation

SOURCE : The directory to be backed up. DESTINATION: The directory where the backup will be stored. DATE : Captures the current date and time to create a unique backup folder.

mkdir -p $DESTINATION/$DATE: Creates the backup directory if it does not exist.

cp -r $SOURCE $DESTINATION/$DATE: Copies the contents of the source directory to the backup directory.

echo "Backup completed on $DATE": Outputs a message indicating the completion of the backup.

Scheduling the backup with Cron

To schedule regular execution of the backup script, utilize the crontab editor by running the following command:

crontab -e

Once in the editor, add the following line to configure the backup schedule:

text* * * * * /path/to/backup_script.sh

This configuration will execute the backup script every minute5. Modify the cron schedule parameters to align with your desired backup frequency.

Disk Usage Monitoring Script

Script Overview

This Bash script monitors disk usage across partitions and issues warnings when usage exceeds a predefined threshold.

bash#!/bin/bashTHRESHOLD=80df -H | grep -vE '^Filesystem|tmpfs|cdrom' | awk '{ print $5 " " $1 }' | while read output;do usage=$(echo $output | awk '{ print $1}' | cut -d'%' -f1) partition=$(echo $output | awk '{ print $2 }') if [$usage -ge $THRESHOLD]; then echo "Warning: Disk usage on $partition is at ${usage}%" fidone

Functionality Breakdown

Threshold Setting : The script initializes with a disk usage threshold of 80%.
Disk Usage Data Collection : Utilizes df -H to retrieve disk usage information in a human-readable format.
Data Filtering : Employs grep to exclude non-essential filesystem entries.
Data Extraction : Uses awk to isolate usage percentages and partition names.
Iterative Processing : Processes each filtered entry using a while loop.
Usage Calculation : Extracts the numerical usage percentage from each entry.
Partition Identification : Isolates the partition name for each entry.
Threshold Comparison : Compares the usage against the predefined threshold.
Alert Generation : Outputs a warning message for partitions exceeding the threshold.

Service Health Check

This script checks if a specified service is running and starts it if not.

bash#!/bin/bashSERVICE="nginx"if systemctl is-active --quiet $SERVICE; then echo "$SERVICE is running"else echo "$SERVICE is not running" systemctl start $SERVICEfi

Explanation:

SERVICE: Specifies the name of the service to check (nginx in this example).
systemctl is-active --quiet $SERVICE: Checks if the service is running.
If the service is running, it prints a confirmation message.
If it is not running, it prints a message and attempts to start the service.

Network Connectivity Check

This script checks network connectivity to a specified host.

bash#!/bin/bashHOST="google.com"OUTPUT_FILE="/home/ubuntu/output.txt"if ping -c 1 $HOST &> /dev/nullthen echo "$HOST is reachable" >> $OUTPUT_FILEelse echo "$HOST is not reachable" >> $OUTPUT_FILEfi

Explanation:

HOST: Specifies the hostname to check.
OUTPUT_FILE: Defines where to write the output.
ping -c 1 $HOST &> /dev/null: Pings the host once, suppressing output.
Depending on the ping result, it writes a reachability status to the output file.

Database Backup

This script creates a backup of a specified MySQL database.

bash#!/bin/bashDB_NAME="mydatabase"BACKUP_DIR="/path/to/backup"DATE=$(date +%Y-%m-%d_%H-%M-%S)mysqldump -u root -p $DB_NAME > $BACKUP_DIR/$DB_NAME-$DATE.sqlecho "Database backup completed: $BACKUP_DIR/$DB_NAME-$DATE.sql"

Explanation:

DB_NAME: Specifies the database to back up.
BACKUP_DIR: Defines where to store the backup.
DATE: Captures the current date and time for a unique filename.
mysqldump command creates a SQL dump of the database.
The echo statement confirms the backup completion and location.

System Uptime Check

This simple script displays the system's uptime.

bash#!/bin/bashuptime -p

Explanation:

uptime -p: Prints the system uptime in a human-readable format.

Listening Ports Monitor

This script lists all listening ports and their associated services.

bash#!/bin/bashnetstat -tuln | grep LISTEN

Explanation:

netstat -tuln: Lists all TCP and UDP listening ports.
grep LISTEN: Filters the output to show only listening ports.

Automatic Package Updates

This script updates and cleans up system packages.

bash#!/bin/bashapt-get update && apt-get upgrade -y && apt-get autoremove -y && apt-get cleanecho "System packages updated and cleaned up"

Explanation:

apt-get update: Updates the package list.
apt-get upgrade -y: Upgrades all installed packages.
apt-get autoremove -y: Removes unnecessary packages.
apt-get clean: Cleans up the package cache.
The echo statement confirms the completion of updates and cleanup.

HTTP Response Time Monitor

This script checks HTTP response times for specified URLs.

bash#!/bin/bashURLS=("https://www.devopsshack.com/" "https://www.linkedin.com/")for URL in "${URLS[@]}"; do RESPONSE_TIME=$(curl -o /dev/null -s -w '%{time_total}\n' $URL) echo "Response time for $URL: $RESPONSE_TIME seconds"done

Explanation:

URLS: An array of URLs to check.
The for loop iterates over each URL.
curl command fetches each URL and measures the total response time.
The script prints the response time for each URL.

System Process and Memory Usage Monitor

This script displays the top processes by memory usage.

bash#!/bin/bashps aux --sort=-%mem | head -n 10

Explanation:

ps aux: Lists all running processes.
--sort=-%mem: Sorts processes by memory usage in descending order.
head -n 10: Displays only the top 10 processes.

These scripts provide valuable tools for various DevOps tasks, from system monitoring to backup and maintenance operations.

Frontend Roboshop

Asad — Fri, 28 Feb 2025 16:27:34 +0000

-> Name -> Choose Spot -> devops-practice - Centos-8-Devops-Practice -> Choose tl.micro -> Choose Procced without Keypair -> Network Settintgs-> Choose allow-all security group -> Advanced -> Request Spet Instances > Customize -> Request Type (Persistent)-> Interruption Behaviour (stop)

Instance Setup Code

{ "MaxCount": 1, "MinCount": 1, "ImageId": "ami-0089b8e98cd95257d", "InstanceType": "t3.micro", "EbsOptimized": true, "NetworkInterfaces": [{ "DeviceIndex": 0, "AssociatePublicIpAddress": true, "SubnetId": "subnet-086a045ade7eae99f", "Groups": [ "sg-0c2e3fdd288a74d3a"] } ], "TagSpecifications": [{ "ResourceType": "instance", "Tags": [ { "Key": "Name", "Value": "frontend" }] }, { "ResourceType": "spot-instances-request", "Tags": [{ "Key": "Name", "Value": "frontend" }] } ], "InstanceMarketOptions": { "MarketType": "spot", "SpotOptions": { "InstanceInterruptionBehavior": "stop", "SpotInstanceType": "persistent" } }, "PrivateDnsNameOptions": { "HostnameType": "ip-name", "EnableResourceNameDnsARecord": true, "EnableResourceNameDnsAAAARecord": false }}

Configuring Server

The frontend service in RoboShop is responsible for serving the web content over Nginx. This service includes the web frame for the web application and serves static content. To accomplish this, a web server is needed. In this case, the developer has chosen Nginx Web Server, which we will install by running the following command:

yum install nginx -y

After installation, we need to start and enable the Nginx service:

systemctl enable nginx systemctl start nginx

Once the service is up and running, we can access it through a browser to ensure that default content is being served. To remove the default content, run:

rm -rf /usr/share/nginx/html/*

Next, we need to download the frontend content by running:

curl -o /tmp/frontend.zip https://roboshop-artifacts.s3.amazonaws.com/frontend.zip

The content can then be extracted using the following command:

cd /usr/share/nginx/html unzip /tmp/frontend.zip

After the frontend content has been extracted, we need to create an Nginx Reverse Proxy Configuration file. Open the file using the following command:

vim /etc/nginx/default.d/roboshop.conf

Add the following content to the file:

proxy_http_version 1.1;location /images/ { expires 5s; root /usr/share/nginx/html; try_files $uri /images/placeholder.jpg;}location /api/catalogue/ { proxy_pass http://localhost:8080/; }location /api/user/ { proxy_pass http://localhost:8080/; }location /api/cart/ { proxy_pass http://localhost:8080/; }location /api/shipping/ { proxy_pass http://localhost:8080/; }location /api/payment/ { proxy_pass http://localhost:8080/; }location /health { stub_status on; access_log off;}

Note that the localhost should be replaced with the actual IP address of the component server to avoid failures on the Nginx Server.

Finally, restart the Nginx service to load the changes to the configuration file:

systemctl restart nginx

Frontend of the Roboshop is set up now.

DevOps Project 1 | GitHub+Jenkins+Docker+ECR+Kubernetes

Asad — Fri, 28 Feb 2025 16:16:33 +0000

Project Summary

Prerequisite:

### GitHub Account
### EC2 Instance
### Jenkins Server
### Docker
### Kubernetes
### ECR

GitHub is a web-based platform that hosts Git repositories and offers additional features such as issue tracking, pull requests, and code reviews. It allows developers to share and collaborate on their code with others.

We will use git hub in this project to work with the following code can be found in the repository;

>..

We created an EC2 instance to install all the necessary packages we need.

Note: We use Ubuntu 20.04 for this project, but you can use any Linux OS.

Git Installation

First, we will install git, to install git we will use the following commands;
To test the installation of git

Jenkins Installation

To install Jenkins we will refer to the document Jenkins Installation Instructions.

https://www.youtube.com/watch?v=edmHwUTs9OA

EC2 (Elastic Compute Cloud) Instance Using AWS CLI through Terminal using Linux

Asad — Mon, 03 Apr 2023 01:19:43 +0000

In order to create EC2 instance Login to the AWS Console and get the following information;

Install AWS CLI for Linux on the computer.

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

Install zip/ Unzip to unzip the aws cli package

sudo apt-get install zip (This should also install unzip option too)

Unzip the file, currently should be in the same directory.

Unzip awsclive2.zip

Navigate to the file and run the command

sudo ./aws/install

Create an Admin user through IAM (Identity Access Management).
To get the Access Key ID
Secret Key

(Note: Google is your best friend if you dont know this search for it.)

Need to know the specific region (for this I will be using us-east-1)
Create keypair through AWS CLI

aws ec2 create-key-pair --key-name awsclikey --query 'keyMaterial' --output text > awsclikey.pem

Change the permission of the key to it has read-only access

chmod 400 awsclikey.pem

A filter name and value pair that is used to return a more specific list of results from a described operation.

aws ec2 describe-key-pairs --key-names awsclikey

We will need a security group to manage the traffic that will be using the EC2 instances.

aws ec2 create-security-group --group-name awscligroup --description "group created with awscli" --vpc-id vpc-0e4167f02a110a4ed

Note: Get the Default VPC Id from the console

Define the inbound rules now

aws ec2 authorize-security-group-ingress --group-id sg-0b2ba2fe2deb772b6 --protocol tcp --port 0-65535 --cidr 0.0.0.0/0

Ingress means input bounds rule
Group id is what we created just now.
Protocol tcp which we will be using
Port has to define the range 0-65535
Define the IP address 0.0.0.0/0
To perform the next step we will need the Image Id (a specific image we will be using for our instance. For this demo we will be using Ubuntu Linux LTS 20).

aws ec2 run-instances --image-id ami-0b93ce03dcbcb10f6 --count 2 --instance-type t2.micro --key-name awsclikey --security-group-ids sg-0b2ba2fe2deb772b6 --subnet-id subnet-013a2aa48b12f80b2

The EC2 instance will be ready shortly.

AWS IAM (Identity Access Management)

Asad — Mon, 03 Apr 2023 01:11:08 +0000

IAM (Identity Access Management) is a single AWS account that lets Root users manage all the users in the environment or the team. IAM helps with authorization and Authentication Access for the team. We can have different permissions and different groups with permission to manage the users.

Note: The user can create an IAM account with the same email as the one used to log in to the AWS Console Account. The user must switch from Root to IAM at the login window.

Once Logged in Navigate to the Search bar and Type IAM or Identity Access Management
The user will be presented with the following dashboard, where users, groups, policies and etc can be managed.

How to create Users in IAM

Users are known as entities, the purpose of creating users is to give the team or the environment access to the services in AWS. We can manage the users with the help of IAM.

Click Users under Access management
Click on Add Users

Add user name , under Set user details.

(U1 is for demonstration purposes)

The user will have two ways to provide the access to the U1,
Access Key - Programmatic Access ( User will connect using CLI, SDK, and other development tools to connect )
Password - AWS Management Console Access ( users will log in using AWS web console )
Let's use Password - AWS Management console access.

We can Add a user to the Group here or create a group for the user if it doesn't already exist.
We can copy permissions from the existing user
We can attach existing policies here as well
We will just create a user at this time.
Click on Next: Tags Button

Add tags is optional and it is used to organize, track and control access for the user. It could be the user's email, description, or job title.
Click on the Next: Review button, to continue

The user should Review all the inputted information and Click Create User.

A user account will be created, You can either download the CSV and share it with the users successfully or Email the CSV file to the user.

Creating Groups in IAM

A Group is known as an identity that has all the IAM

users in a single environment. The groups are used to specify the permissions for multiple users. The groups make permission to manage and apply to multiple users.

To Create Groups Navigate to the left panel, under Access Management.
Click on User groups.

Give the group a specific name (ec2-access)
You can also add users to the group, but it doesnt have to be now.

Under Attach permission policies, there are many permissions to choose from, we need to create a group for users to give only read-only permissions.
Select AmazonGlacierReadOnlyAccess
Click Create Group

The group ecs-access is created under the group with the defined permissions.

Sharing File/Folder with Aws S3

Asad — Mon, 03 Apr 2023 01:03:13 +0000

Go to your S3 bucket

Users can create folders in the S3 bucket and upload the files and folder in the S3 bucket

In order to share the document from S3, Click on a specific file to open it.
Navigate to the Objects Action Tab
Click on Share with a pre-signed URL

You can define if you want to share for minutes or hours.

After creating a pre-signed URL
Copy the URL with the intending party and do remind them the file/folder is available for a certain amount of time.

AWS S3 Bucket

Asad — Mon, 03 Apr 2023 00:59:53 +0000

Aws S3 service is known as a simple storage service. S3 is also considered a bucket where important files and folders are stored. The files and folders we store in S3 are known as objects. The S3 default region will be Global, we can change it manually to our particular region.

In the AWS console search for S3.

Click Create Bucket

Under General Configuration give your bucket a unique name.

Leave the Object Ownership as the default

Under Block Public Access settings for this bucket, leave it as the default

Leave Bucket Versioning as default too.

Skip the Tags and leave the Default encryption as default too.

Dont need to make any changes in Advance, Click on Create a bucket

You should have your first AWS S3 bucket. ]]>

Basic Git & GitHub for DevOps Engineers

Asad — Sun, 26 Mar 2023 18:19:07 +0000

What is Git?

Git is a popular and widely used version control system that allows developers to keep track of changes made to their code over time, collaborate with others, and work on multiple versions of their code.

What is a GitHub?

GitHub is a web-based platform that provides hosting for Git repositories and offers additional features such as issue tracking, pull requests, and code reviews. It allows developers to share and collaborate on their code with others.

What is Version control?

Version control is a system that allows developers to keep track of changes made to their code over time, and enables them to revert to previous versions or collaborate with others on the same codebase.

Types of Version Controls

There are two main types of version control systems: centralized and distributed.

Centralized version control systems store code in a central server, while distributed version control systems create multiple copies of the repository on different computers.
Distributed version control offers several advantages over centralized version control, such as the ability to work offline and make commits locally, easier collaboration and branching, and a faster workflow.

Everything Combined

Git is a version control system that allows developers to keep track of changes made to their code, GitHub is a platform that provides hosting for Git repositories and additional features, version control is a system that allows developers to manage and track changes made to their code over time, there are two main types of version control systems (centralized and distributed), and distributed version control offers several advantages over centralized version control.

10 Basic git Commands

git init: Initializes a new Git repository in your current working directory.
git add: Adds changes made to your code to the staging area, which prepares them to be committed.
git commit: Commits changes to the repository and creates a new snapshot of the code.
git status: Shows the current status of the repository, including which files have been modified or added, and which files are ready to be committed.
git log: Shows a history of all the commits made to the repository, along with their messages and other details.
git branch: Lists all the branches in the repository, and shows which branch you are currently on.
git checkout: Switches to a different branch or a specific commit.
git pull: Updates the local repository with changes made in the remote repository.
git push: Sends changes made locally to the remote repository.
git clone: Creates a copy of a remote repository on your local machine.

Git has many more powerful features and commands that can help you manage your code and collaborate with others.

Task 1: New Repository in Github and Cloning it locally.

A GitHub account already exists. I created the repository Day-8-task on git. I will clone the repo and make changes to the README.md file and commit the changes to GitHub.

To clone the repository git clone followed by the repository link

git clone https://github.com/Arafique458/Day-8-Task.git

To configure the credentials, I will be using a Secret Access token to connect to the repository.

git config --global user.name "arafique458"

git config --global user.email "arafique458@gmail.com

To access the cloned directory

cd Day-8-task

To make changes to the README.md file

vim README.md

After making changes check the status of the file modified.

To stage, the changes git add . (this will stage all the files in the directory or we can specify the file want to stage)

To push the changes to the main repository in the GitHub git push origin main (I was prompted to enter credentials, I used the email address of the git hub and Access token)

Task 2: File in the repository changed and commit was made in the repository using Git

GitHub repository before making a commit