LINUX OS
By Mr. Ashok
Phone: +91 9985 39 66 77
Location: H.No - 7-1-413/2, Beside Sonabhai
Temple, Ameerpet, Hyderabad - 500016
What is Operating System?
-> Operating System is a software which is used to interact with computer
-> Operating System is acting as mediator between users and computer hardware components
-> Operating System is mandatory to use any computer
-> OS provides environment to run other applications
(Browser, Notepad, Paint, Calc)
-> The OS came into market in 1950
-> Microsoft released its first OS in 1981 (MS DOS)
Windows OS
-> Developed by Microsoft Company
-> It is having GUI (Graphical user interface)
-> It is single user based Operating System (only one person can use this at a time)
-> It is commercial (paid)
-> Less Security
-> It is recommended for personal use
- Watch Movies
- Using Internet
- Playing Games
- Attending Online classes
- Store data
1
Linux OS
-> Linux is Community Based OS
-> Linux is Free & Open-Source OS
-> Linux is Multi User Based OS
-> Linux provides High Security
-> Linux is recommended to use for Applications, Servers, Databases etc
Note: In real-time, we will use Linux OS only to setup infrastructure required to run our
application
-> Linux OS is not only for Administrators, even developers and testers also will use Linux OS in
real-time to monitor our application and application servers and application logs.
History of Linux
-> In 1991, a student 'Linus Torvalds' developed this Linux OS
-> Linux Torvalds identified some challenges in UNIX OS and he suggested some changes
for Unix OS but UNIX OS Team rejected 'Linux Torvalds 'suggestions
-> Linus Torvalds used Minux OS to develop Linux
Linus + Minux -
-> First Two letters from his name and last 3 letters from Minux OS
LI + NUX => LINUX
-> Linus Torvalds released LINUX OS with source code into market so that anybody can modify
LINUX OS thats why it is called as Open-Source Operating System.
-> As Linux OS is open source, so many people and companies taken that Linux OS and modified
according to their requirements and released into market with different names those are called as
Linux Distributions.
Note: 200+ Linux Distributions are available in the market.
2
Environment Setup
We can setup Linux machine in multiple ways
1) We can install Linux OS directly in computer
2) We can setup Linux OS in windows machine using Virtual Box
3) We can setup Linux Virtual Machine Cloud Platform like AWS and Azure
Note: In this note we will see how to setup Linux VM in AWS Cloud
AWS Account Creation
-> Create account in AWS (it will ask debit/credit card) - selected cards are accepted
3
4
5
6
7
8
9
Create Linux VM using AWS EC2 service
10
11
12
13
Download Mobaxterm software to connect with Linux VM
Connect with Linux VM using Public IP and pem file
Note: Once work is completed then stop your Linux VM in EC2 to avoid billing
➔ Open Mobaxterm software and connect with Linux VM
14
➔ Once we connect with EC2 instance using Mobaxterm we can see screen like below
Linux Commands
$ whoami : It will display currently logged in username
$ pwd : present working directory
$ date : To display current date
$ cal : To display calendar
15
Linux File System
-> In Linux everything will be represented as a file
-> We have 3 types of files in Linux
1) Ordinary File / Normal File (it will start with -)
2) Directory File (it will start with d)
3) Link File (it will start with l)
-> The file which contains data is called as ordinary file
-> Directory file is equal to folder (it can contain files and folders)
-> The file which is having linking is called as Link File
-> touch : it is used to create empty file
$ touch f1.txt
$ touch f2.txt
$ touch f3.txt f4.txt
-> To display files we will use 'ls' command
$ ls
-> To create a file with data we will use 'cat' command
$ cat > hello.txt
//write data
press CTRL + d (to save and exit)
$ cat hello.txt (To display file data)
$ cat >> hello.txt (To append data in the file)
//write data
press CTRL + d (to save and exit)
-> To create directory we will use 'mkdir' command
$ mkdir dirname
-> To remove the file we will use 'rm' command
$ rm filename
-> To remove empty directory we will use 'rmdir' command
$ rmdir dirname
16
-> 'ls' is used to list out all files & directories available in the given directory
Note: we can pass several options for 'ls' commands
-> ls : It will display all files in alphabetical order (a to z)
-> ls -r : It will display all files in reverse of alphabetical order (z to a)
-> ls -l : It will display long listing of files
-> ls -t : It will display all files based on last modified date and time. Most recent file will be display
at top and old files will display at bottom.
-> ls -rt : It will display all files based on reverse of last modified date and time. Old files will
display at top and recent files will display bottom.
-> ls -a : It will display all files including hidden files (hidden files will start with .)
-> ls -li : It will display files with inode numbers.
-> ls -lR : It will display all files and directories along with sub directoris content
Note: -R represents recursive
Note: We can use several options for ls command at a time. When we are using multiple options
order of the options is not important
$ ls -ltr
$ ls -tlr
$ ls -l -t -r
$ ls -trl
Note: All the above commands will give same output
-> To display content of given directory we can execute like below
$ ls -l <dirname>
-> To delete a file we will use 'rm' command
$ rm <filename>
-> To delete empty directory we will use 'rmdir' command
$ rmdir <dirname>
-> To delete non-empty directory we will use 'rm' command like below
$ rm -r dirname
-> To display file content we will use 'cat' command
17
$ cat filename
-> To display file content with line numbers we will use '-n' option
$ cat -n filename
-> To display multiple files content at a time execute command like below
$ cat file1 file2 file3
-> Copy one file data into another file using 'cat' command
$ cat f1.txt > f8.txt
-> Copy more than one file data into another file
$ cat f1.txt f2.txt > f9.txt
-> 'tac' command is used to reverse file content
$ tac filename
-> 'rev' command is used to reverse each line content of the file
$ rev filename
-> head command is used to display file data from top (default 10 lines)
$ head filename
$ head -n 5 data.log (first 5 lines data)
$ head -n 20 data.log (first 20 lines data)
-> tail command is used to display file data from bottom (default 10 lines)
$ tail filename (last 10 lines data)
$ tail -n 100 filename (last 100 lines data)
$ tail +25 filename (it will display data from 25th line to bottom)
Note: To see on-growing logs we can use '-f' option
$ tail -f data.log (Live log message we can see)
-> It is used to count no.of lines, no.of words and no.of characters in the file
$ wc f1.txt
-> To copy the data from one file to another file
$ cp one.txt two.txt ( or ) $ cat one.txt > two.txt
$ cp f1.txt f2.txt f3.txt (invalid syntax)
-> We can't copy morethan one file data using 'cp' command. To copy multiple files data we
should go for 'cat' command
18
$ cat f1.txt f2.txt > f3.txt
-> To rename files we will use 'mv' command
$ mv f1.txt f1111.txt
$ mv dirname dirnewname
Note: We can use 'mv' command for renaming and moving files
-> To compare files we can use below commands
$ cmp f1.txt f2.txt
$ diff f1.txt f2.txt
-> cmp command will display only first difference in given 2 two files
-> diff command will display all the differences in the content
-> 'grep' stands for global regular expression print.
-> 'grep' command will process the text line by line and prints any lines which matches given
pattern.
Ex: I want to print all lines which contains 'NullPointerException'
$ grep -i 'NullPointerException' *
Note: We can install grep using below command
$ sudo yum install grep
//search for the lines which contains given word in the given filename
$ grep 'word' filename
//search for the lines which are having exception keyword in server.log file
$ grep -i 'exception' server.log
//search for the given text in present directory and in sub-directories also
$ grep -R 'exception'
=> We can pass several options for 'grep' command
-c : This prints only the count of files that matches give pattern
-i : ignore case-sensitivity
-n : Display the matched lines and their line numbers
-l : Displays only file names that matches the pattern
-h : Displays matched lines without file names
19
Working with Text Editors in Linux
-> The default editor that comes with the LNIX operating system is called vi (visual editor).
-> Using vi editor, we can edit an existing file or we create a new file from scratch
-> We can also use this vi editor to just read a text file.
Modes of Operation in vi editor
There are three modes of operations in vi:
1) command mode
2) insert mode
3) escape mode
Command Mode:
When vi starts up, it is in Command Mode. This mode is where vi interprets any characters we
type as commands and thus does not display them in the window
This mode allows us to move through a file, and to delete, copy, or paste a piece of text.
To enter into Command Mode from any other mode, it requires pressing the [Esc] key. If we press
[Esc] when we are already in Command Mode, then vi will beep or flash the screen.
Insert mode:
This mode enables you to insert text into the file.
Everything that’s typed in this mode is interpreted as input and finally, it is put in the file.
The vi always starts in command mode. To enter text, you must be in insert mode.
To come in insert mode you simply type i.
To get out of insert mode, press the Esc key, which will put you back into command mode.
Last Line Mode (Escape Mode):
Line Mode is invoked by typing a colon [:], while vi is in Command Mode.
The cursor will jump to the last line of the screen and vi will wait for a command.
This mode enables you to perform tasks such as saving files, executing commands.
There are following way you can start using vi editor :
Commands and their Description:
vi filename: Creates a new file if it already not exist, otherwise opens existing file.
vi -R filename : Opens an existing file in read only mode.
20
view filename : Opens an existing file in read only mode.
$ vi f1.txt
=> After making changes if we want to save those changes then execute :wq
=> After making changes if we don't want to save those changes then execute :q!
Moving within a File(Navigation):
To move around within a file without affecting text must be in command mode (press Esc twice).
Here are some of the commands can be used to move around one character at a time.
Commands and their Description:
k : Moves the cursor up one line.
j : Moves the cursor down one line.
h : Moves the cursor to the left one character position.
l : Moves the cursor to the right one character position.
0 or | : Positions cursor at beginning of line.
$ : Positions cursor at end of line.
W : Positions cursor to the next word.
B : Positions cursor to previous word.
( : Positions cursor to beginning of current sentence.
) : Positions cursor to beginning of next sentence.
H : Move to top of screen.
nH : Moves to nth line from the top of the screen.
M : Move to middle of screen.
L : Move to bottom of screen.
nL : Moves to nth line from the bottom of the screen.
colon along with x : Colon followed by a number would position the cursor on line number
represented by x.
Usecase:
-> We will use 'vi' editor to perform below activities
a) To edit config files of our application
b) To edit shell script files
21
SED command:
SED command in LNIX stands for stream editor and it can perform lots of functions on file like
searching, find and replace, insertion or deletion.
Though most common use of SED command in LNIX is for substitution or for find and replace.
By using SED you can edit files even without opening them, which is much quicker way to find and
replace something in file, than first opening that file in VI Editor and then changing it.
SED is a powerful text stream editor. Can do insertion, deletion, search and replace (substitution).
SED command in lnix supports regular expression which allows it perform complex pattern
matching.
Example:
$ cat > myfile.txt
unix is great os. unix is opensource. unix is free os.
learn operating system.
unix linux which one you choose.
unix is easy to learn.unix is a multiuser os. Learn unix. unix is a powerful.
Replacing or substituting string :
Sed command is mostly used to replace the text in a file. The below simple sed command replaces
the word “unix” with “linux” in the file
$ sed 's/unix/linux/' myfile.txt
By default, the sed command replaces the first occurrence of the pattern in each line and it won’t
replace the second, third…occurrence in the line.
Replacing the nth occurrence of a pattern in a line :
Use the /1, /2 etc flags to replace the first, second occurrence of a pattern in a line. The below
command replaces the second occurrence of the word “unix” with “linux” in a line.
$sed 's/unix/linux/2' geekfile.txt
Replacing all the occurrence of the pattern in a line :
The substitute flag /g (global replacement) specifies the sed command to replace all the
occurrences of the string in the line.
$ sed 's/unix/linux/g' myfile.txt
Deleting lines from a particular file
SED command can also be used for deleting lines from a particular file. SED command is used for
performing deletion operation without even opening the file
22
To Delete a particular line say n in this example
$ sed '5d' myfile.txt
-> To Delete a last line : $ sed '$d' myfile.txt
-> To Delete from nth to last line : $ sed '12,$d' myfile.txt
Note: By default SED command changes will not store in file.
=> To make SED command changes to file permanently we will use '-i' option.
$ sed -i 's/unix/linux/g' myfile.txt
Note: With above command 'unix' keyword will be replaced with 'linux' keyword in the file
permanently.
Linux File permissions:
To create a secure environment in Linux, you need to learn about user groups and permissions. For
example, if you work in a company and you want the finance department to read a file but not
make any modification to it, then you need to use permissions in Linux. It is a must for every
programmer working with Linux nowadays.
Let’s start by talking about the ownership of Linux files.
User: the owner of the file (person who created the file).
Group: the group can contain multiple users.
Therefore, all users in that group will have the same permissions. It makes things easier than
assign permission for every user you want.
Other: any person has access to that file, that person has neither created the file, nor are they in
any group which has access to that file.
We will work with this part “-rw-r–r–".
The characters mean:
‘r’ = read.
‘w’ = write.
‘x’ = execute.
‘-’ = no permission.
-rw-r--r--
-: It represents file
rw: User
r: Group
r: Other
23
As we see above, the empty first part means that it is a file. If it were a directory then it will be the
letter “d” instead.
The second part means that the user “Home” has read and write permissions but he does not have
the execute one.
The group and others have only the read permission.
Let’s change the permissions using the chmod command.
$ chmod o+w section.txt
This command will add the write permission for other users to my text file “section.txt”.
Now if you try to execute ls -l then you will see -rw-r--rw-
“o” refers to others, “g” for the group, “u” for the user, and “a” for all.
Now let’s add the execute permission to the user with:
$ chmod u+x section.txt
The permissions will be -rwxr--rw-
If you want to remove the permission, you can use the same method but with “-” instead of “+”.
For example, let’s remove the execute permission from the user by:
$ chmod u-x section.txt
And the permissions now are: -rw-r--rw-
Also, you can use Symbolic Mode to modify permissions like the following:
Number Permission
0 No permission
1 Execute
2 Write
3 Execute and Write
4 Read
5 Read and Execute
6 Read and Write
7 Read, Write and Execute
For example, let’s give every permission for all with:
$ chmod 777 section.txt
Then the permissions will be: -rwxrwxrwx.
Let’s remove the execute from the group and the write from other by:
24
$ chmod 765 section.txt
Then the permission will be : -rwxrw-r-x
Working with User Accounts
-> Linux is multi user based operating systems
-> Within one Linux machine we can create multiple user accounts
-> Multiple users can access single linux machine and can perform multi-tasking
-> When we launch EC2 instance with Amazon Linux OS, we got by default 'ec2-user' user account
Create a user:
$ sudo useradd <uname>
-> After creating user account we can verify user account details using 'id' command
$ id <uname>
-> 'id' command will display user account information
-> Check the files available in home directory
$ ls -l
(We can see ec2-user folder and newly created user folder)
(That means we have 2 user accounts in our machine)
-> After creating a new user and setting a password to it, you can log in from the terminal
$ su - <uname>
Delete a user:
$ sudo userdel <uname>
If you try that command, you will notice that the user directory has not been deleted and you
need to delete it by yourself.
You can use this automated command to do everything for you:
$ sudo userdel <uname>
25
User groups:
-> A group is a collection of users.
-> The primary purpose of the groups is to define a set of privileges like read, write, or execute
permission for a given resource that can be shared among the users within the group.
Create a group:
You can see all of the groups you have by opening the following file:
$ cat /etc/group
$ sudo groupadd <groupname>
Add user to a group:
$ sudo usermod -aG <group-name> <username>
-> verify user groups using command
$ id username
Delete user from a group:
$ sudo gpasswd -d <username> <groupname>
Delete a group:
$ sudo groupdel <groupname>
Working with 'find' and 'locate' commands
-> find and locate commands are used to search files in linux machines
locate command:
The locate Command find will search for data in local db
$ sudo yum install mlocate
$ locate apache
$ locate -c apache
$ locate -c *.txt
$ locate -S (to see locate database)
Note: when we create new files it will take some time to update those files in mlocate db
find command:
-> find command will search for the files in entire linux file system.
-> find command providing advanced searching technique
-> Using find command, we can search for the files based on name and type also.
26
2. Find Files Under Home Directory
# find /home -name f1.txt
7. Find Files With 777 Permissions
# find . -type f -perm 0777 -print
19. Find all Empty Files
# find /home -type f -empty
20. Find all Empty Directories
# find /home -type d -empty
Note: As find command is scanning entire file system, it will take more time to give search results.
Chown command:
-> The chown command changes user ownership of a file & directory in Linux
-> Every file is associated with an owning user or group
-> We can check the ownership of a file using 'ls -l'
# changing owner of a file
$ chown NewUser FILE
Note: we can change owner using userid also
$ chown 1001 filename
# changing group of a file
$ chown :NewGroup FILE
# We can change group using group id also
$ chown :1003 sample
# Change Owner and the Group
$ chown NewUser:NewGroup FILE
-> 'man' command is like a help command. It is used to understand command syntax and options.
$ man cat
-> To see ip address we will use 'ifconfig' command
$ ifconfig
-> 'ping' command is used to check connectivity
27
$ ping <ip>
-> 'curl' command is used to get response from the server
$ curl <url>
-> 'wget' command is used to download resources from internet
$ wget <url>
How to install Software in Linux Machine:
-> In linux we have package manager to install a software
Note: Amazon Linux / CentOS / Red Hat : yum is the package manager
Note : Ubuntu : apt-get is the package manager
# update existing packages in linux
$ sudo yum update -y
# install git client
$ sudo yum install git
# check git version
$ git --version
# install maven
$ sudo yum install maven
# check maven version
$ mvn –version
# install java software
$ sudo yum install java
# install Java 1.8 version
$ sudo yum install java-1.8.0-openjdk
28
Installing Web Server in Linux VM (Amazon Linux):
1) Connect to EC2 instance
2) Execute below commands to install Apache server (httpd)
$ sudo yum update -y
$ sudo yum install httpd
$ service httpd start
Note: Check accessing apache server from browser using EC2 VM public IP
-> If server is not accessible then, enable HTTP port in Security Group of our EC-2 VM
-> After adding security group try accessing EC2 instance using IP
Ex: http://52.66.101.3/
-> You can modify html page content
$ cd /var/www/html
$ sudo vi index.html
<h1> Welcome to Ashok IT - Website</h1>
-> Save the content and close the file ( press Esc -> :wq)
-> Now access public IP in browser
Shell Scripting
What is shell?
-> Shell is responsible for reading commands given by user
-> Shell will verify command and will give instructions to kernel to process that command
-> If command is invalid shell will give error
-> Kernel will execute our command with System Hard Components
-> Shell acts as mediator between User and Kernel
What is Scripting?
-> Scripting means set of commands mentioned in a file for execution
-> Scripting is used to automate our routine work
-> For example i want to execute below commands every day as a linux user
29
$ date
$ cal
$ whoami
$ pwd
$ ls -l
-> Instead of executing all these commands manually we can keep them in a file and we can
execute that file.
-> The file which contains set of commands for execution is called as 'Script file'
What is Shell Scripting?
-> Shell Scripting is used to execute set of commands using a script file
-> When we execute script file then shell will read those commands and will verify commands
syntax
-> Shell will give instructions to 'Kernel'
-> Kernel will give instructions to hardware components to perform actual operation
Types of Shells
-> There are several shells available in linux OS
1) Bourne Shell
2) Bash Shell
3) Korn Shell
4) CShell
5) TShell
6) ZShell
# Display all the shells of our Linux machines
$ cat /etc/shells
# Display the default shell of our Linux machine
$ echo $SHELL
Note: The most commonly used shell in Linux in is 'BASH SHELL'.
Note: Shell Script files will have .sh extension
30
Working with First Shell Script Program
# Create a script file
$ vi task.sh
whoami
pwd
date
-> Save the file and close it (ESC + :wq)
# Run the shell script (Option-1)
$ sh task.sh
Note: If we get permission denied then we should provide 'execute' permission using 'chmod'
command
# Run the shell script (Option-2)
$ ./task
What is sha-bang in shell script?
-> Sha-bang is used to specify which shell should be used to process our script
Syntax :
#! /bin/bash
***************Shell Script - 2*************
#! /bin/bash
echo "Welcome to Scripting"
echo "Scripting is used to automate regular work"
echo "Scripting requires lot of practise"
*****************Shell Script - 3 ***********************
#! /bin/bash
echo "Enter your name:"
read name
echo "Good Morning $name"
31
********************* Shell Script - 4 ******************************
#! /bin/bash
a=10
b=20
c=$(($a + $b))
echo "Sum of $a and $b is = $c"
*************************** Shell Script - 5 *******************************
#! /bin/bash
echo "Enter First Number"
read a
echo "Enter Second Number"
read b
c=$(($a + $b))
echo "Sum of $a and $b is = $c"
END
Variables
-> Variables are place-holders to store the value
-> Varibles are key-value pairs
-> In Shell Scripting there is no concept of Data Type.
-> Every value will be treated as text/string
Ex:
name=ashok
age=30
email=ashokitschool@gmail.com
phno=1234
-> Variables are divided into 2 types
1) Environment Variables or System variables
2) User Defined Variables
-> The variables which are already defined and using by our system are called as
Environment/System variables
32
Ex:
$ echo $USER
$ echo $SHELL
-> Based on our requirement we can define our own variables those are called as user defined
variables
Ex:
name=ashok
age=30
$echo $name $ age
Variable Rules
-> We should not use special symbols like -, @, # etc....
-> Variable name should not start with digit
Note: It is recommended to use uppercase characters for variable name
-> we can use 'readonly' for variable so that variable value modification will not be allowed
Command Line Arguments
-> The arguments which will pass to script file at the time of execution
-> Cmd args are used to supply the values dynamically to the script file
Ex:
$ sh demo.sh ashokit 30
-> We can access cmd args in script file like below
$# - no.of args
$0 - script file name
$1 - First Cmd Arg
$2 - Second Cmd Arg
$3 - Third Cmd Arg
$* - All Cmd Args
-> To comment any single line we can use '#'
echo 'hi'
#echo 'hello'
33
-> We can comment multiple lines also in script file like below
<<COMMENT
.....................
COMMENT
-> We can hold script execution for some time using 'sleep' command
#! /bin/bash
echo $#
echo $0
echo $1
sleep 30s
echo $2
#echo $*
Conditional Statements
-> Conditional statements are used to execute commands based on condition
Syntax:
if [ conition ]
then
stmts
else
stmts
fi
-> If given condition satisfied then if statments will be executed otherwise else statements will be
executed
if [ condition ]
then
stmts
elif [ condition ]
then
stmts
34
else
stmts
fi
Ex:
#!/bin/bash
echo "Enter Your Favorite Color"
read COLOR
if [ $COLOR == 'red' ]
then
echo "Your are cheerful"
elif [ $COLOR == 'blue' ]
then
echo "You are joyful"
else
echo "You are lucky"
fi
Working with loops
-> Loops are used to execute stmts multiple times
-> We can use 2 types of loops
1) Range based loop ( ex: for loop )
2) Conditional based loop ( ex: while loop )
35
For Loop Example
#! /bin/bash
for ((i=1; i<=10; i++))
do
echo "$i"
done
While loop Example
#! /bin/bash
i=10
while [ $i -ge 0 ]
do
echo "$i"
let i--;
done
Infinite Loop
#! /bin/bash
while true
do
echo "This is my loop stmt"
done
Note: To stop infinite loop we will use 'ctrl + c'
36
Functions
-> The big task can be divided into smaller tasks using functions
-> Function is used to perform an action / task
-> Using functions we can divide our tasks logically
-> Functions are re-usable
Syntax:
function functionaName( ) {
// commands to execute
Writing welcome function
#! /bin/bash
function welcome(){
echo "Welcome to functions...";
echo "I am learning Shell Scripting";
echo "Shell Scripting is used to automate our regular work";
# call the function
welcome
Function with Parameters
#! /bin/bash
function welcome ( ) {
echo "$1";
# call function
welcome Linux
welcome AWS
welcome DevOps
37
