Linux users, groups, sudo आणि file permissions: adduser, chmod, chgrp आणि पहिला shell script

By Ravindra Bagale, trainer LinkedIn Last updated: 8 October 2026

चला, सुरू करूया. मागच्या class मध्ये ls -l च्या प्रत्येक ओळीच्या सुरुवातीला - किंवा d दिसला. आज त्या ओळीचा बाकीचा भाग वाचायचा: नऊ r w x अक्षरं, आणि त्यानंतरची दोन नावं, owner आणि group. ती एकाच प्रश्नाचं उत्तर देतात: या file चं कोण काय करू शकतो? हे का महत्त्वाचं आहे ते बघायला आपण एका छोट्या team साठी खरे users बनवणार, त्यांच्या नावाने login करणार, sudo बरोबर पद्धतीने वापरणार, chmod ने permissions बदलणार, group सोबत files share करणार, आणि शेवटी तुमचा पहिला shell script लिहिणार. Server चालू ठेवा आणि प्रत्येक command माझ्यासोबत type करा.

या class मध्ये काय शिकणार

ls -l मधले owner आणि group columns का महत्त्वाचे
Team ची गोष्ट: सगळ्यांनी एकच ec2-user वापरणं धोक्याचं का
IAM users vs Linux users
प्रत्येक Linux वरचे default users
नवीन user ला त्याच नावाचा group का मिळतो
sudo adduser, आणि लांबचा sudo su → adduser → exit रस्ता
नवीन user म्हणून SSH ने login (authorized_keys च्या steps)
touch vs sudo touch: file चा owner कोण
whoami, who आणि w: तीन वेगळी उत्तरं
/ tree आणि ec2-user कुठे लिहू शकतो
sudo कधी वापरायचा, आणि कधी नाही
u, g आणि o साठी r w x
chmod u-r, u+r, u-w, u+w: खऱ्या messages सोबत live demo
sudo permissions ओलांडतो; owner नसाल तर "Operation not permitted"
Group सोबत sharing: groupadd, usermod -aG, chgrp, chmod g+w
तुमच्या नवीन files rw-rw-r-- (664) का दिसतात, rw-r--r-- (644) का नाही
x bit आणि तुमचा पहिला script, my.sh
कधीच न संपणारा loop script, आणि Ctrl+C का महत्त्वाचा
घरी करायचे tasks

1. Owner आणि group columns का महत्त्वाचे

का. तुमच्या laptop वर तुम्ही एकटेच असता. Server share केलेला असतो: एकाच वेळी अनेक लोक आणि programs त्यावर काम करतात. प्रत्येक file चा owner कोण आणि बाकी कोण तिला हात लावू शकतो, हे Linux ला माहीत हवं. ls -l मधले दोन columns नेमकं हेच सांगतात.

कसं. तुमच्या home folder मध्ये, एक file आणि एक folder असताना:

[ec2-user@ip-172-31-xx-xx ~]$ ls -l
total 4
-rw-rw-r--. 1 ec2-user ec2-user 6 Jan  5 10:15 my.txt
drwxr-xr-x. 2 ec2-user ec2-user 6 Jan  5 10:15 ravi

प्रत्येक ओळीची सुरुवात वाचा:

पहिलं character: - = file, d = directory (मागचा chapter).
पुढची नऊ characters: r w x चे तीन गट. Section 12 मध्ये सविस्तर.
पहिलं नाव (ec2-user): owner, म्हणजे file ज्याची आहे तो user.
दुसरं नाव (ec2-user): file ज्या group ची आहे तो.

बाकीचे columns (links, size, date) Linux मध्ये move, rename आणि delete मध्ये समजावले आहेत.

Handwritten board: ls -l at the top; two lines starting with a dash and a d, each followed by three boxed sets of r w x letters; ec2-user ec2-user on each line with user written under the first column and group under the second; an arrow from my.txt to the owner; on the left r arrow read, w arrow write, x arrow execute. — **Class board वरून:** Class board: file आणि folder साठी box केलेला type आणि r w x चे sets असलेला ls -l, owner column वर user, group column वर group, आणि r = read, w = write, x = execute.

Figure 1. ls -l: आधी type, मग user (owner), group आणि others साठी तीन वेळा r w x, मग owner चं नाव आणि group चं नाव.

2. Team ची गोष्ट: सगळ्यांनी एकच ec2-user वापरणं धोक्याचं का

का. समजा आपण Instagram सारखं एक app बनवतोय. Website, mobile app चं backend आणि MySQL database, सगळं एकाच server वर चालतं. फक्त backend मध्येच हजारो files असू शकतात, आणि त्यावर पाच developers ची team काम करते.

App चे भाग:

Frontend, user ला जे दिसतं: Android app (Java किंवा Kotlin, APK म्हणून), iOS app (Swift किंवा Objective-C, IPA म्हणून), cross-platform apps (React Native, Flutter), आणि website (React, Angular).
Backend, server वरचा code: PHP, Python, Java, .NET किंवा Node.js (बहुतेक Express.js सोबत). उदा. app नवीन reels मागतो, तेव्हा latest.php सारखी file database वाचते आणि data परत पाठवते.
Database: MySQL data ठेवतं.

Server फक्त data पाठवतो, screen नाही. Phones, tablets, TVs, car screens सगळ्यांचे आकार वेगळे, म्हणून प्रत्येक device वरचं app स्वतःची screen काढतं.

Handwritten board: a box Front-end with three branches Android, ios app and webapp; a box backend with a line to server and python; Db with an arrow to MySQL. — **Class board वरून:** Class board: frontend म्हणजे Android app, iOS app आणि web app; backend म्हणजे server ची बाजू, उदा. Python; database म्हणजे MySQL.

Correction

Class मध्ये Express.js frontend tools सोबत सांगितला. तो Node.js वर चालणारा backend framework आहे. PHP आणि Python पण server-side (backend) languages आहेत.

प्रॉब्लेम. पाचही developers एकाच .pem key ने ec2-user म्हणून login करतात. एक दिवस code चा एक folder delete होतो, चुकून किंवा मुद्दाम. कोणी केलं? प्रत्येक file आणि प्रत्येक action वर ec2-user च. ओळखायला काहीच मार्ग नाही.

Classroom line

If one of them deletes it, how will we know who did it?

उपाय: प्रत्येकाला एक Linux user. Ravi ravi म्हणून login करतो, Ramesh ramesh म्हणून, आणि प्रत्येक file दाखवते ती कोणी बनवली.

Figure 2. डावीकडे: पाच developers एकच ec2-user वापरतात, म्हणून delete झालेली file कोणी केली ते कळत नाही. उजवीकडे: ravi आणि ramesh चे स्वतःचे users, आणि ls -l प्रत्येक file चा owner दाखवतो.

Correction

Class मध्ये असं वाटलं की सगळे एकच IP address वापरतात हा प्रॉब्लेम आहे. तसं नसतं; प्रत्येक developer आपापल्या network मधून connect करतो. खरा प्रॉब्लेम म्हणजे एकच username आणि एकच key: Linux सगळ्यांसाठी ec2-user च लिहितो, म्हणून action कोणत्या माणसाचं ते जोडता येत नाही.

3. IAM users vs Linux users

का. Root user, IAM users, MFA आणि पहिला EC2 server मध्ये आपण IAM users बनवले आहेत. ते पुरेसे नाहीत का?

काय. हे दोन वेगळे थर आहेत:

IAM users AWS account वर काम करतात: servers launch, stop किंवा terminate करणं, console उघडणं, volumes बनवणं. कोणत्या IAM user ने server launch केला ते CloudTrail दाखवू शकतं.
Linux users एका server च्या आत काम करतात: file चा owner कोण, ती कोण edit करू शकतो, SSH ने कोणी login केलं.

Linux च्या आत latest.php कोणी edit केली, ते IAM ला काहीच माहीत नसतं.

Classroom line

The IAM user's job ends at launching the server.

Classroom line

It has nothing to do with the work we do inside the server.

Figure 3. IAM users AWS account वर काम करतात. एका server च्या आत root, ec2-user, ravi, ramesh सारखे Linux users files चे owner असतात आणि SSH ने login करतात.

Ravindra Bagale's Tip

या दोघांमध्ये एक पूल आहे: AWS Systems Manager Session Manager मध्ये server वर shell कोण उघडू शकतो ते IAM ठरवतं, आणि त्या sessions चा log पण ठेवता येतो. पण या course सारखं साधं SSH वापरताना लोकांना वेगळं ठेवतात ते Linux users च.

4. Default users

काय. प्रत्येक Linux server वर सुरुवातीपासून दोन users असतात:

root: superuser. System folders त्याचे असतात आणि तो काहीही करू शकतो.
एक नेहमीचा user, cloud image ने बनवलेला, म्हणजे तुम्हाला root म्हणून login करावं लागत नाही:

Server image	Default user
Amazon Linux	`ec2-user`
Ubuntu	`ubuntu`
CentOS	`centos` (CentOS Stream 9 images वर `ec2-user`)
Debian	`admin`

Classroom line

Linux has two users from the start, by default.

Correction

Class मध्ये CentOS चा default user admin असं सांगितलं. CentOS cloud images वर तो centos असतो (नवीन CentOS Stream 9 images वर ec2-user). admin हा Debian images चा default user आहे.

Homes. नेहमीचे users /home/<name> मध्ये राहतात: /home/ec2-user, पुढे /home/ravi. root चं home /root आहे, /home/root नाही.

तुम्ही कोण ते prompt सांगतो: नेहमीच्या user साठी शेवटी $, root साठी #.

5. नवीन user ला त्याच नावाचा group मिळतो

काय. प्रत्येक user ला त्याच नावाचा एक group मिळतो, आणि तोच त्या user चा मुख्य group असतो:

User	मुख्य group
`root`	`root`
`ec2-user`	`ec2-user`
`ravi`	`ravi`

म्हणूनच ls -l मध्ये ec2-user ec2-user दिसलं: owner ec2-user, group ec2-user.

स्वतः बघा:

id ec2-user
uid=1000(ec2-user) gid=1000(ec2-user) groups=1000(ec2-user),4(adm),10(wheel),190(systemd-journal)

gid=1000(ec2-user) हा मुख्य group. wheel हा sudo वापरू शकणारा group.

6. User बनवणं: sudo adduser

का. Users फक्त root बनवू शकतो. तुम्ही ec2-user आहात, म्हणून त्या एका command साठी root ची मदत लागते.

लांबचा रस्ता (तीन commands):

[ec2-user@ip-172-31-xx-xx ~]$ sudo su
[root@ip-172-31-xx-xx ec2-user]# adduser ravi
[root@ip-172-31-xx-xx ec2-user]# exit
exit
[ec2-user@ip-172-31-xx-xx ~]$

sudo su: sudo = "superuser do", su = "switch user". दोन्ही मिळून: root बना. Prompt मध्ये root येतो आणि शेवटी #.
adduser ravi: root user बनवतो.
exit: परत ec2-user, परत $.

छोटा रस्ता (एक command):

sudo adduser ravi

Classroom line

We can turn these three commands into one, like this.

हे काय बनवतं: user ravi, group ravi, आणि home folder /home/ravi.

Classroom line

A group named ravi will be created too, and a folder named ravi as well.

Check करा:

sudo adduser ramesh
id ravi
uid=1001(ravi) gid=1001(ravi) groups=1001(ravi)
ls /home
ec2-user  ramesh  ravi

Figure 4. Animation: sudo adduser ravi user ravi, त्याच नावाचा group ravi, आणि फक्त ravi ला उघडता येणारा home folder /home/ravi बनवतो.

Correction

Command "sudo user add" असा वाचला गेला. Commands आहेत adduser आणि useradd. Amazon Linux 2023 वर adduser हे useradd चंच दुसरं नाव आहे: तो काही विचारत नाही आणि password set करत नाही (गरज असेल तरच sudo passwd ravi ने द्या). Ubuntu वर adduser हा जास्त मदत करणारा script आहे, जो password आणि माहिती विचारतो.

का. Ravi ने ravi म्हणून login करावं, ec2-user म्हणून नाही. पण अगदी नवीन user कडे key नसते, आणि EC2 वर password login बंद असतं. म्हणून सुरुवातीला हे fail होतं:

ssh -i key.pem ravi@SERVER_PUBLIC_IP
ravi@SERVER_PUBLIC_IP: Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

कसं. /home/ravi/.ssh/authorized_keys मध्ये एक public key ठेवा. Practice साठी ec2-user ची key copy करा (ती तुमच्या .pem शी जुळते). या commands ec2-user म्हणून चालवा:

sudo mkdir /home/ravi/.ssh
sudo cp ~/.ssh/authorized_keys /home/ravi/.ssh/
sudo chown -R ravi:ravi /home/ravi/.ssh
sudo chmod 700 /home/ravi/.ssh
sudo chmod 600 /home/ravi/.ssh/authorized_keys

प्रत्येक ओळ काय करते:

Ravi च्या home मध्ये .ssh folder बनवा.
परवानगी असलेल्या public keys ची list त्यात copy करा.
ravi ला owner करा (आत्तापर्यंत त्या root च्या होत्या, कारण root ने बनवल्या).
Folder फक्त ravi उघडू शकतो (700).
Key list फक्त ravi वाचू आणि लिहू शकतो (600).

आता तीच command चालते, आणि prompt मध्ये नवीन user दिसतो:

ssh -i key.pem ravi@SERVER_PUBLIC_IP
[ravi@ip-172-31-xx-xx ~]$ touch ravi.txt
[ravi@ip-172-31-xx-xx ~]$ ls -l
total 0
-rw-rw-r--. 1 ravi ravi 0 Jan  5 10:15 ravi.txt

File वर ravi ravi आहे. Ramesh च्या files वर ramesh ramesh येईल.

Correction

Board वर user बनवल्यावर लगेच ssh -i key.pem ravi@... दाखवलं. ते फक्त /home/ravi/.ssh/authorized_keys मध्ये public key ठेवल्यानंतरच चालतं. खूप उघड्या folders मधल्या keys पण SSH नाकारतो, म्हणून chown आणि chmod 700/600 च्या ओळी महत्त्वाच्या. खऱ्या team मध्ये प्रत्येकजण आपली स्वतःची public key पाठवतो आणि तुम्ही तीच ठेवता, म्हणजे कोणालाही .pem share करावी लागत नाही.

8. touch vs sudo touch: file चा owner कोण

काय. जो user command चालवतो, तो त्याने बनवलेल्या गोष्टीचा owner.

[ec2-user@ip-172-31-xx-xx ~]$ touch a.txt
[ec2-user@ip-172-31-xx-xx ~]$ sudo touch b.txt
[ec2-user@ip-172-31-xx-xx ~]$ ls -l
total 0
-rw-rw-r--. 1 ec2-user ec2-user 0 Jan  5 10:15 a.txt
-rw-r--r--. 1 root     root     0 Jan  5 10:15 b.txt

touch a.txt: ec2-user ने बनवली, म्हणून ec2-user ec2-user.
sudo touch b.txt: root ने बनवली, म्हणून root root.

Classroom line

Put sudo in front of any command; it simply means the root user is doing that work.

(दोन files ना वेगवेगळ्या permissions, rw-rw-r-- आणि rw-r--r--, का मिळाल्या ते section 17 मध्ये.)

9. whoami, who आणि w

काय. तीन छोट्या commands, तीन वेगळी उत्तरं:

whoami: तुमचं आत्ताचं user नाव.
who: आत्ता login असलेले सगळे, त्यांचा terminal आणि login ची वेळ.
w: login असलेले सगळे, आणि server किती वेळ चालू आहे, load, आणि प्रत्येकजण काय चालवतोय.

Try करा. तुमच्या output मध्ये तुमच्या वेळा आणि IP addresses दिसतील:

whoami
ec2-user

sudo whoami
root

मग Ravi पण login असताना (इथले IP addresses उदाहरण आहेत):

who
ec2-user pts/0        2026-01-05 10:15 (203.0.113.25)
ravi     pts/1        2026-01-05 10:18 (203.0.113.40)

w
 10:20:01 up  2:05,  2 users,  load average: 0.00, 0.01, 0.00
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
ec2-user pts/0    203.0.113.25     10:15    0.00s  0.03s  0.00s w
ravi     pts/1    203.0.113.40     10:18    1:02   0.01s  0.01s -bash

Correction

Class मध्ये तिन्ही commands एकच काम करतात असं सांगितलं. तसं नाही: whoami फक्त तुमचं नाव देतो, who login असलेल्या सगळ्या users ची list देतो, आणि w त्यात uptime, load आणि प्रत्येक user काय चालवतोय ते जोडतो.

10. / tree आणि ec2-user ची हद्द

काय. सगळं / च्या खाली लटकलेलं असतं: bin, sbin, home, root, dev, opt, usr, var आणि अजून. हे सगळे root चे. नेहमीचा user फक्त स्वतःच्या home मध्येच लिहू शकतो.

sudo शिवाय try करा:

touch /a.txt
touch: cannot touch '/a.txt': Permission denied
touch /home/a.txt
touch: cannot touch '/home/a.txt': Permission denied
mkdir /test
mkdir: cannot create directory ‘/test’: Permission denied
ls /home/ravi
ls: cannot open directory '/home/ravi': Permission denied

शेवटचं: Amazon Linux वर नवीन home drwx------ असतं, म्हणून दुसऱ्या user च्या home मध्ये डोकावणं पण बंद.

Classroom line

Go to / or /home and try to make a file without sudo; it won't work, you'll get Permission denied.

sudo सोबत, root करतो:

sudo touch /home/a.txt
sudo mkdir /test
sudo touch /home/ravi/notes.txt

File दुसऱ्याच्या home मध्ये ठेवायची असेल तर पूर्ण path लिहा, /home/ravi/notes.txt.

Classroom line

As the root user, we can work in every folder.

Figure 5. / पासूनचं tree. ec2-user फक्त /home/ec2-user च्या आत (हिरवं) लिहू शकतो. बाकी सगळीकडे (लाल) command पुढे sudo नसेल तर Permission denied.

11. sudo कधी वापरायचा, आणि कधी नाही

sudo वापरा फक्त तुमच्या home च्या बाहेरच्या किंवा system च्या कामासाठी: packages install करणं, users बनवणं, /etc मधल्या files edit करणं, दुसऱ्या user च्या home मध्ये लिहिणं.

स्वतःच्या home मध्ये sudo नको. तिथे त्याची गरज नसते, आणि तो root च्या files बनवतो ज्या मग तुम्हाला नेहमीसारख्या edit करता येत नाहीत:

sudo touch notes.txt
echo hello > notes.txt
-bash: notes.txt: Permission denied

nano notes.txt file उघडतो पण [ File 'notes.txt' is unwritable ] म्हणतो. Folder तुमचा असल्यामुळे delete मात्र करता येते, पण rm आधी विचारतो:

rm notes.txt
rm: remove write-protected regular empty file 'notes.txt'?

चुकून बनली असेल तर स्वतःकडे परत घ्या:

sudo chown ec2-user:ec2-user notes.txt

Correction

Board वर ec2-user च्या स्वतःच्या home मधल्या file साठी sudo touch a.txt लिहिलं होतं. तिथे sudo ची गरज नाही. sudo लावलं की file root root होते, आणि परत sudo शिवाय ती edit करता येत नाही.

Ravindra Bagale's Tip

sudo type करायच्या आधी स्वतःला विचारा: "मी home च्या बाहेर आहे का, किंवा system बदलतोय का?" उत्तर नाही असेल तर sudo काढा. आणि root shell (sudo su) मध्ये गरजेपेक्षा जास्त वेळ थांबू नका; root चं काम झालं की लगेच exit.

12. u, g आणि o साठी r w x

काय. ती नऊ characters म्हणजे तिघांचे तीन sets, नेहमी r w x याच क्रमाने:

u = user, owner (ls -l मधलं पहिलं नाव).
g = group (दुसरं नाव).
o = others, server वरचे बाकी सगळे users.

प्रत्येक set मध्ये: r = read, w = write, x = execute, - = ती permission नाही.

उदाहरणं:

rw- = read आणि write, execute नाही.
r-- = फक्त read.
r-x = read आणि execute, write नाही.

म्हणजे -rw-r--r-- चा अर्थ: owner वाचतो आणि लिहितो; group वाचतो; others वाचतात.

Handwritten board: rw- r-- r-- with user, group and other users written under the three sets; ec2-user ec2-user my.txt with an arc between the two names and ravi written under the group; in the top right corner root, ec2-user, ravi and ramesh. — **Class board वरून:** Class board: my.txt साठी user ला rw-, group ला r-- आणि other users ना r--; owner ec2-user, group ec2-user; group मध्ये ravi सारखा दुसरा user पण असू शकतो. वर उजवीकडे users root, ec2-user, ravi आणि ramesh.

13. chmod: owner चेच स्वतःचे r आणि w काढून बघूया

का. chmod (change mode) ती नऊ अक्षरं बदलतो. ती समजायचा सगळ्यात सोपा मार्ग: स्वतःचीच एक permission काढा आणि काय बिघडतं ते बघा.

Commands कशा वाचायच्या: chmod u-w my.txt = user (owner) कडून write काढून घ्या (-). + परत देतो.

सुरुवात (Amazon Linux वर तुमच्या नवीन files rw-rw-r-- असतात):

echo hello > my.txt
ls -l my.txt
-rw-rw-r--. 1 ec2-user ec2-user 6 Jan  5 10:15 my.txt

Read काढा:

chmod u-r my.txt
ls -l my.txt
--w-rw-r--. 1 ec2-user ec2-user 6 Jan  5 10:15 my.txt
cat my.txt
cat: my.txt: Permission denied

nano my.txt रिकामी screen आणि [ Error reading my.txt: Permission denied ] दाखवतो. chmod u+r my.txt ने परत द्या.

Write काढा:

chmod u-w my.txt
ls -l my.txt
-r--rw-r--. 1 ec2-user ec2-user 6 Jan  5 10:15 my.txt

nano my.txt text दाखवतो आणि [ File 'my.txt' is unwritable ] म्हणतो. काहीतरी बदला आणि save करायला Ctrl+O दाबा: [ Error writing my.txt: Permission denied ]. बाहेर पडायला Ctrl+X, मग बदल टाकून द्यायला N. chmod u+w my.txt ने write परत द्या, आणि save परत चालतं.

Figure 6. Animation: chmod u-r नंतर cat म्हणतो Permission denied; chmod u+r आणि chmod u-w नंतर nano म्हणतो file unwritable आहे आणि save fail होतं; chmod u+w नंतर save परत चालतं.

Handwritten board: rw- r-- r-- with u, g and o under the three sets and ec2-user ec2-user my.txt next to them; below, chmod u-w my.txt, then r-- r-- r--, then chmod u+w my.txt; on the right side of a line, chmod u-r my.txt and chmod u+r my.txt. — **Class board वरून:** Class board: ec2-user च्या my.txt साठी rw- r-- r-- वर u, g, o; chmod u-w my.txt ने ते r--r--r-- होतं, chmod u+w my.txt write परत देतो; उजवीकडे chmod u-r my.txt आणि chmod u+r my.txt.

Group च्या rw- ने मदत का केली नाही? ec2-user हा group ec2-user मध्ये आहे, आणि त्या group कडे अजून rw- आहे. पण Linux एकच set बघतो: तुम्ही owner असाल तर तो u bits वापरतो आणि तिथेच थांबतो. g bits owner नसलेल्या group members साठी असतात.

Figure 7. Linux या क्रमाने बघतो: root ला परवानगी; owner ला फक्त u bits; group member ला g bits; बाकी सगळ्यांना o bits. म्हणून owner कडे r-- असेल तर group कडे rw- असलं तरी save होत नाही.

Correction

Class मध्ये nano "exit" ने किंवा Ctrl+C ने बंद केला. Nano Ctrl+X ने बंद होतो (बदललेली file असेल तर save करायचं का ते विचारतो: Y किंवा N). Nano मध्ये Ctrl+C फक्त cursor ची जागा दाखवतो.

Ravindra Bagale's Tip

सगळ्या permissions काढल्या तरी owner स्वतःच्या file चा chmod कधीही परत करू शकतो. म्हणून हा demo safe आहे. फक्त system files वर करून बघू नका.

14. sudo permissions ओलांडतो

काय. root r w x checks बघतच नाही. u-w तसंच असताना:

ls -l my.txt
-r--rw-r--. 1 ec2-user ec2-user 6 Jan  5 10:15 my.txt
sudo nano my.txt

एक ओळ बदला, Ctrl+O आणि Enter दाबा: nano म्हणतो [ Wrote 1 line ]. u-r असताना पण sudo cat my.txt text दाखवतो.

Classroom line

Root is above everyone; these limits don't apply to it.

म्हणूनच sudo एवढा ताकदवान आहे, आणि म्हणूनच तो जपून वापरायचा.

15. "Operation not permitted": तुम्ही owner नाही

काय. File चा chmod फक्त owner, किंवा root, करू शकतो.

sudo touch u.txt
ls -l u.txt
-rw-r--r--. 1 root root 0 Jan  5 10:15 u.txt
chmod u-w u.txt
chmod: changing permissions of 'u.txt': Operation not permitted

u.txt root ची आहे, म्हणून ec2-user तिच्या permissions बदलू शकत नाही. sudo chmod u-w u.txt चाललं असतं.

दोन वेगळे errors:

Permission denied: तुम्ही जे करायला गेलात (वाचणं, लिहिणं, उघडणं) ते r w x bits करू देत नाहीत.
Operation not permitted: फक्त owner किंवा root करू शकतो असं काहीतरी तुम्ही केलं, उदा. chmod.

का. Ravi आणि Ramesh दोघंही "reel upload" module वर काम करतात. Ramesh ला Ravi च्या files edit करायच्या आहेत. others ना write (o+w) दिलं तर server वरचा प्रत्येक user त्या edit करू शकेल. Group फक्त team ला write देतो.

कसं. Team चा group बनवा, दोघांना त्यात टाका, आणि homes च्या बाहेरचा share केलेला folder वापरा (homes drwx------ असतात, म्हणून Ramesh /home/ravi मध्ये शिरूच शकत नाही):

sudo groupadd reels
sudo usermod -aG reels ravi
sudo usermod -aG reels ramesh
sudo mkdir /srv/reels
sudo chgrp reels /srv/reels
sudo chmod g+w /srv/reels

groupadd reels: नवीन group.
usermod -aG reels ravi: Ravi ला Group reels मध्ये add करा. -a नसेल तर -G त्याचे बाकीचे extra groups बदलून टाकेल.
chgrp reels /srv/reels: folder चा group reels होतो.
chmod g+w /srv/reels: group members त्यात files बनवू शकतात.

Check करा:

id ramesh
uid=1002(ramesh) gid=1002(ramesh) groups=1002(ramesh),1003(reels)
ls -ld /srv/reels
drwxrwxr-x. 2 root reels 6 Jan  5 10:15 /srv/reels

नवीन groups पुढच्या login ला लागू होतात, म्हणून Ravi आणि Ramesh logout करून परत login करतात. मग Ravi एक file बनवतो. तिचा group अजून ravi च आहे, म्हणून Ramesh अजून त्यात लिहू शकत नाही:

[ravi@ip-172-31-xx-xx ~]$ echo "<?php // upload" > /srv/reels/upload.php
[ravi@ip-172-31-xx-xx ~]$ ls -l /srv/reels/upload.php
-rw-rw-r--. 1 ravi ravi 16 Jan  5 10:15 /srv/reels/upload.php

[ramesh@ip-172-31-xx-xx ~]$ echo "// ramesh" >> /srv/reels/upload.php
-bash: /srv/reels/upload.php: Permission denied

Ravi (owner, आणि reels चा member) file team च्या group ला देतो:

[ravi@ip-172-31-xx-xx ~]$ chgrp reels /srv/reels/upload.php
[ravi@ip-172-31-xx-xx ~]$ chmod g+w /srv/reels/upload.php
[ravi@ip-172-31-xx-xx ~]$ ls -l /srv/reels/upload.php
-rw-rw-r--. 1 ravi reels 16 Jan  5 10:15 /srv/reels/upload.php

[ramesh@ip-172-31-xx-xx ~]$ echo "// ramesh" >> /srv/reels/upload.php
[ramesh@ip-172-31-xx-xx ~]$ cat /srv/reels/upload.php
<?php // upload
// ramesh

Ramesh आता लिहू शकतो, पण chmod अजूनही नाही, कारण owner Ravi आहे:

[ramesh@ip-172-31-xx-xx ~]$ chmod o+w /srv/reels/upload.php
chmod: changing permissions of '/srv/reels/upload.php': Operation not permitted

Class मध्ये एक झटपट पद्धत पण सांगितली: sudo usermod -aG ravi ramesh Ramesh ला Ravi च्या स्वतःच्या group मध्ये टाकतो. Ramesh पोहोचू शकेल त्या files साठी ते चालतं, पण /home/ravi च्या आत नाही, कारण तो फक्त Ravi उघडू शकतो. Project group आणि share केलेला folder हा जास्त स्वच्छ मार्ग.

17. तुमच्या files 664 का दिसतात, 644 का नाही

काय. Board वर नवीन files rw-r--r-- दाखवल्या. Amazon Linux वर ec2-user म्हणून तुम्ही बनवलेल्या files rw-rw-r-- दिसतात. दोन्ही बरोबर; ते umask वर ठरतं, म्हणजे प्रत्येक नवीन file मधून permissions काढून घेणारी एक setting:

umask
0002

नवीन file rw-rw-rw- (666) पासून सुरू होते.
ec2-user चा umask 0002 फक्त others चा w काढतो → rw-rw-r-- (664).
root चा umask 0022, जो group चा w पण काढतो → rw-r--r-- (644). म्हणूनच section 8 मध्ये sudo touch ने rw-r--r-- बनली.

Amazon Linux ec2-user सारख्या users साठी 0002 वापरतं कारण प्रत्येक user चा स्वतःचा खाजगी group असतो, म्हणून group write safe असतं. बरेच दुसरे systems सगळ्यांसाठी 0022 वापरतात, त्यामुळे board वर दिसलेलं 644 येतं.

आकड्यांमध्ये: r = 4, w = 2, x = 1, प्रत्येक set साठी बेरीज. rw- = 6, r-- = 4, rwx = 7. म्हणजे 664 = rw-rw-r--, आणि section 7 मधले 700/600 म्हणजे "फक्त owner".

18. x bit आणि तुमचा पहिला shell script

का. समजा तुम्ही रोज त्याच पाच commands type करता. त्या एकदाच एका file मध्ये लिहा, आणि ती file चालवा. ती file म्हणजे script, आणि ती चालवायला Linux ला x (execute) bit लागतो.

Handwritten board: a box holding six lines: echo enter folder name, read name with name underlined, mkdir $name, cd $name, touch $name.txt, echo $name greater-than $name.txt; on the right the word King. — **Class board वरून:** Class board: पहिला script. echo "enter folder name", read name, mkdir $name, cd $name, touch $name.txt, echo $name > $name.txt. King हे prompt ला type केलेलं एक उदाहरण नाव होतं. या page वर #!/bin/bash आणि "$name" भोवती quotes जोडले आहेत.

लिहा: nano my.sh, या ओळी type करा, Ctrl+O, Enter ने save करा, आणि Ctrl+X ने बाहेर पडा:

#!/bin/bash
echo "Enter a folder name:"
read name
mkdir "$name"
cd "$name"
touch "$name.txt"
echo "$name" > "$name.txt"

ओळ by ओळ:

#!/bin/bash (shebang): ही file bash ने चालवा.
echo: text परत दाखवतो.
read name: तुम्ही काहीतरी type करेपर्यंत थांबतो, आणि ते name variable मध्ये ठेवतो.
"$name": तुम्ही type केलेली value. Quotes मुळे space असलेलं नाव एकाच तुकड्यात राहतं.
mkdir, cd, touch: folder बनवा, त्यात जा, त्याच नावाची file बनवा.
echo "$name" > "$name.txt": ते नाव त्या file मध्ये लिहा.

Classroom line

What does echo do? Whatever we tell it, it says back to us.

आधी x शिवाय चालवून बघा:

ls -l my.sh
-rw-rw-r--. 1 ec2-user ec2-user 120 Jan  5 10:15 my.sh
./my.sh
-bash: ./my.sh: Permission denied

Classroom line

Until we give it x permission, it won't execute.

Owner ला x द्या, आणि चालवा:

chmod u+x my.sh
ls -l my.sh
-rwxrw-r--. 1 ec2-user ec2-user 120 Jan  5 10:15 my.sh
./my.sh
Enter a folder name:
reels
ls reels
reels.txt
cat reels/reels.txt
reels

-rwxrw-r--: आता owner कडे x आहे. Colour असलेल्या terminal मध्ये नाव हिरवं होतं.
./my.sh: ./ म्हणजे "याच folder मधली file". ते नसेल तर bash फक्त नेहमीच्या command folders मध्ये शोधतो आणि command not found म्हणतो.
तुम्ही reels type केलं; script ने folder reels, file reels/reels.txt बनवली, आणि त्यात reels लिहिलं.

Figure 9. Animation: x bit नसताना ./my.sh Permission denied देतो; chmod u+x my.sh तो देतो; मग ./my.sh नाव विचारतो आणि folder व file बनवतो.

दोन गोष्टी लक्षात घ्या:

Script संपल्यावर तुम्ही त्याच folder मध्ये असता. cd script च्या स्वतःच्या shell मध्ये झालं, तुमच्या नाही.
त्याच नावाने परत चालवलं तर mkdir म्हणतो mkdir: cannot create directory ‘reels’: File exists. my notes सारखं दुसरं नाव देऊन बघा: quotes मुळे एकच folder मिळतो, my notes. Quotes नसते तर mkdir $name ने दोन folders बनले असते, my आणि notes.

Correction

Board वरच्या script मध्ये पहिली ओळ नव्हती आणि quotes नव्हते. प्रत्येक bash script #!/bin/bash ने सुरू करा, आणि variables quote करा: mkdir "$name", cd "$name", touch "$name.txt". आणि read हा shell चा built-in command आहे (type read म्हणतो read is a shell builtin), keyword नाही.

19. कधीच न संपणारा loop, आणि Ctrl+C

काय. Script कायम repeat होऊ शकतो. loop.sh बनवा:

#!/bin/bash
while true; do
  echo "Hello"
  sleep 1
done

while true; do ... done: true खरं आहे तोपर्यंत do आणि done मधल्या ओळी परत परत चालवा, म्हणजे कायम.
sleep 1: प्रत्येक वेळी एक second थांबा.

चालवा:

chmod u+x loop.sh
./loop.sh
Hello
Hello
Hello
^C

तुम्ही Ctrl+C दाबेपर्यंत तो दर second ला Hello दाखवतो. Ctrl+C तुमच्या terminal मध्ये समोर चालू असलेला program थांबवतो.

Classroom line

Whenever you get stuck anywhere, cancel it: Ctrl+C.

Correction

Board वर loop while true : असा लिहिला. बरोबर रूप while true; do (किंवा while :; do). आणि class मध्ये म्हटलं तसा endless loop म्हणजे virus नाही. तो फक्त दाखवतो की एखादा भरकटलेला script तुम्ही थांबवेपर्यंत चालत राहून CPU कसा खाऊ शकतो. म्हणूनच Ctrl+C लक्षात ठेवायचा.

20. घरी करायचे tasks

Try at home

Task 1: users

sudo adduser ने ravi आणि ramesh users बनवा. id ravi आणि ls /home ने check करा.
/home/ravi/.ssh/authorized_keys set करा (section 7) आणि दुसऱ्या terminal मधून ravi म्हणून login करा.
ravi म्हणून whoami, मग touch ravi.txt आणि ls -l चालवा. ec2-user च्या terminal मध्ये who आणि w चालवा.

Task 2: sudo

ec2-user म्हणून touch /a.txt करून बघा. Error वाचा. मग sudo सोबत करा आणि ls -l /a.txt ने owner बघा.
Home मध्ये touch x.txt आणि sudo touch y.txt करा. Owner आणि permissions ची तुलना करा.
sudo chown ec2-user:ec2-user y.txt ने y.txt स्वतःकडे परत घ्या.

Task 3: chmod

echo hello > my.txt, मग chmod u-r my.txt आणि cat my.txt. मग chmod u+r my.txt.
chmod u-w my.txt, nano मध्ये उघडा, save करून बघा, Ctrl+X ने बाहेर पडा. मग chmod u+w my.txt.
sudo touch u.txt आणि chmod u-w u.txt करून बघा. कोणता error येतो, आणि का?

Task 4: groups आणि scripts

Section 16 group web आणि folder /srv/web घेऊन परत करा.
my.sh लिहा (section 18), chmod u+x च्या आधी आणि नंतर चालवा, आणि space असलेल्या नावाने test करा.
loop.sh लिहा, चालवा, आणि Ctrl+C ने थांबवा.

झालं की sudo userdel -r ravi आणि sudo userdel -r ramesh ने practice users काढून टाका, मग instance stop करा (परत वापरणार नसाल तर terminate).

Recap

थोडक्यात

ls -l: type, मग user (owner), group आणि others साठी r w x, मग owner चं नाव आणि group चं नाव.
सगळ्यांचा एकच ec2-user कोणी काय केलं ते लपवतो. प्रत्येकाला स्वतःचा Linux user द्या.
IAM users AWS account वर काम करतात; Linux users server च्या आत.
Default users: root आणि ec2-user (Amazon Linux), ubuntu, centos (CentOS) किंवा admin (Debian). root चं home /root. $ = नेहमीचा user, # = root.
sudo adduser ravi user, group ravi आणि /home/ravi बनवतो. लांबचा रस्ता: sudo su, adduser ravi, exit.
ravi म्हणून SSH साठी /home/ravi/.ssh/authorized_keys मध्ये key लागते, owner ravi, आणि 700/600.
touch → owner ec2-user; sudo touch → owner root.
whoami = तुम्ही; who = login असलेले सगळे; w = सगळे आणि uptime, load, ते काय चालवतात.
sudo शिवाय ec2-user फक्त /home/ec2-user च्या आत लिहू शकतो. sudo फक्त home च्या बाहेर.
chmod u-r, u+r, u-w, u+w owner चे bits बदलतात. Group कडे जास्त असलं तरी owner ला फक्त u bits लागू.
root checks ओलांडतो. chmod फक्त owner किंवा root: नाहीतर "Operation not permitted".
Group सोबत share: groupadd, usermod -aG, chgrp, chmod g+w, मग परत login.
तुमच्या files 664 कारण umask 0002; root च्या 644 (umask 0022).
Script ला #!/bin/bash, quote केलेलं "$name", chmod u+x, आणि चालवायला ./my.sh.
Endless loop म्हणजे virus नाही. Ctrl+C तो थांबवतो. Nano Ctrl+X ने बंद होतो.

Samjla ka? Ghari don users banva, tyancha group banva, ani pahila script swatah chalvun bagha.

Ravindra Bagale, trainer: linkedin.com/in/ravindra-bagale. User, group, folder आणि file ची नावं (ravi, ramesh, reels, my.txt, my.sh वगैरे) शिकण्यासाठीची उदाहरणं आहेत. Commands आणि messages box वर GNU coreutils, bash, nano आणि shadow-utils ने तपासले, आणि Amazon Linux 2023 server च्या settings शी जुळवले (adduser → useradd, home folders 700, umask 0002, nano 8.3); prompt मधला hostname, who/w मधले IP addresses आणि ls -l मधल्या dates उदाहरण म्हणून आहेत.

Linux users, groups, sudo आणि file permissions: adduser, chmod, chgrp आणि पहिला shell script

1. Owner आणि group columns का महत्त्वाचे

2. Team ची गोष्ट: सगळ्यांनी एकच ec2-user वापरणं धोक्याचं का

3. IAM users vs Linux users

4. Default users

5. नवीन user ला त्याच नावाचा group मिळतो

6. User बनवणं: sudo adduser

7. नवीन user म्हणून SSH ने login

8. touch vs sudo touch: file चा owner कोण

9. whoami, who आणि w

10. / tree आणि ec2-user ची हद्द

11. sudo कधी वापरायचा, आणि कधी नाही

12. u, g आणि o साठी r w x

13. chmod: owner चेच स्वतःचे r आणि w काढून बघूया

14. sudo permissions ओलांडतो

15. "Operation not permitted": तुम्ही owner नाही

16. Sharing साठी groups

17. तुमच्या files 664 का दिसतात, 644 का नाही

18. x bit आणि तुमचा पहिला shell script

19. कधीच न संपणारा loop, आणि Ctrl+C

20. घरी करायचे tasks

Recap