🖼️ See the drawing + lab 🏠 Course home 🌿 Branch on GitHub ✏️ View source

🖼️ आकृती आणि labThe drawing + lab पूर्ण पानावर उघडा ↗Open full page ↗

👥 धडा 02 — Users, groups आणि root: कार्डे आणि वर्गाच्या याद्या

📍 तुम्ही इथे आहात: 12 पैकी धडा 02 · मागे: lesson-01-why-iam · पुढे: lesson-03-policies

📦 या ब्रँचमध्ये काय आहे

धडा 01, आणि त्यासोबत पहिल्या identities: IAM users (aishwarya, katrina, dipika), policies वाहून नेणारा एक group (teachers), आणि तुम्ही तिजोरीत बंद करून ठेवता तो root user. iam/demo.py मधला users() दाखवतो की परवानग्या यादीनुसार चालतात.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

ओळखपत्र कार्यालय शाळेतल्या प्रत्येक मोठ्या व्यक्तीला तिच्या नावाचे एक कार्ड देते — तेच IAM user. "ऐश्वर्या ग्रंथालय उघडू शकते" हे ऐश्वर्याच्याच कार्डवर लिहिणे दमवणारे असते: नवी शिक्षिका आली की पुन्हा लिहा, आणि कोणी सोडून गेले की प्रत्येक कार्ड शोधत बसा.

म्हणून कार्यालय त्याऐवजी वर्गाच्या याद्या 📋 ठेवते. नियम यादीला लावलेले असतात — "teachers यादीतील प्रत्येकजण reports वाचू शकतो" — आणि लोक फक्त यादीत येतात किंवा जातात. दीपिका teachers मध्ये सामील होते: ती reports वाचू शकते. ती बाहेर पडते: ती वाचू शकत नाही.

आणि मास्टर चावी 🗝️ — प्रत्येक दार उघडणारी, शाळा बांधली तेव्हा बनवलेली — ती दुसऱ्या कुलुपासह (MFA) तिजोरीत जाते. तोच root user.

🗺️ आकृती

flowchart LR
    root["🗝️ root user<br/>MFA · no access keys · in the safe"]
    grp["📋 group: teachers<br/>read-reports · own-homework-folder"]
    a["🪪 aishwarya"] --> grp
    s["🪪 katrina"] --> grp
    k["🪪 dipika<br/>no groups"]
    grp -->|"1 policies apply to members"| ok["✅ s3:GetObject report"]
    k -.->|"2 nothing attached"| no["🚫 IMPLICIT DENY"]

🗺️ काढलेली आकृती + एक lab: https://school-edh.pages.dev/iam/lesson-diagrams.html#l02

❓ काय

IAM user — एका account मधली दीर्घकाळ टिकणारी identity, console password आणि/किंवा जास्तीत जास्त दोन access keys (AKIA…) सह. आजचा सल्ला: लोक IAM Identity Center ने sign in करतात (धडा 10) आणि machines roles वापरतात (धडे 05–06); IAM users उरलेल्या थोड्याच प्रसंगांसाठी.
IAM group — policies जोडलेली users ची यादी. Group हा principal नाही: त्याचे नाव resource policy मध्ये घेता येत नाही आणि तो request वर सही करू शकत नाही. Group मध्ये दुसरे groups असू शकत नाहीत. एक user जास्तीत जास्त 10 groups मध्ये असू शकतो.
User च्या effective permissions = user वरच्या policies अधिक तो ज्या ज्या group मध्ये आहे त्यांच्या policies (मग धडा 04 प्रमाणे evaluate केलेल्या).
Root user — MFA चालू करा, root च्या कोणत्याही access keys delete करा, संपर्क माहिती अद्ययावत ठेवा, आणि ज्यांना त्याची गरजच आहे अशा थोड्या कामांसाठीच तो वापरा (उदा. account बंद करणे, account च्या काही settings बदलणे).

🤔 का

व्यक्तींना लावलेल्या परवानग्या भरकटतात: कोणी team बदलते आणि जुने अधिकार तसेच ठेवते, सोडून गेलेल्याकडे key राहते. याद्यांना लावलेल्या परवानग्या एकदा तपासल्या जातात आणि यादीतील सगळ्यांना लागू होतात. आणि रोज वापरला जाणारा root user म्हणजे खिशात ठेवलेली मास्टर चावी.

🔧 कसे (या repo मध्ये)

iam/demo.py मध्ये GROUPS हे teachers ला दोन policies शी जोडते आणि MEMBERS यादीत कोण आहे ते सांगते; policies_of(name) user च्या groups मधून त्याच्या policies गोळा करते. users() तीन जणांसाठी तोच प्रश्न विचारतो, मग dipika ला यादीत जोडतो आणि पुन्हा विचारतो.

🧪 करून पाहा

python3 iam/demo.py users
python3 - <<'EOF'
import sys; sys.path.insert(0, "iam"); from evaluate import decide, load
groups = {"teachers": ["read-reports", "own-homework-folder"], "exam-board": ["deny-delete-reports"]}
def policies(*gs): return [(p, load(p)) for g in gs for p in groups[g]]
dipika, notes = "arn:aws:iam::111122223333:user/dipika", "arn:aws:s3:::school-homework/dipika/notes.txt"
print("no groups         ", decide(dipika, "s3:PutObject", notes, identity=policies())[0])
print("teachers          ", decide(dipika, "s3:PutObject", notes, identity=policies("teachers"))[0])
print("teachers + exams  ", decide(dipika, "s3:GetObject", "arn:aws:s3:::school-reports/term1.pdf", identity=policies("teachers", "exam-board"))[0])
EOF

खऱ्या account वर (AWS CLI आणि credentials लागतात):

aws iam create-group --group-name teachers
aws iam create-policy --policy-name read-reports --policy-document file://iam/policies/read-reports.json
aws iam attach-group-policy --group-name teachers --policy-arn arn:aws:iam::111122223333:policy/read-reports
aws iam create-user --user-name dipika
aws iam add-user-to-group --user-name dipika --group-name teachers
aws iam list-groups-for-user --user-name dipika
aws iam get-account-summary --query 'SummaryMap.AccountMFAEnabled'    # 1 = root has MFA

✅ तपासा — तुम्हाला काय दिसायला हवे

users हे aishwarya आणि katrina साठी ✅ ALLOW print करतो (identity policy read-reports#ReadReports allows it), कोणत्याही group मध्ये नसलेल्या dipika साठी 🚫 IMPLICIT DENY, आणि dipika teachers मध्ये सामील होताच ✅ ALLOW. तुमचा snippet IMPLICIT DENY, ALLOW, ALLOW print करतो — दुसऱ्या group मध्ये सामील झाल्याने नियम वाढतात; exam board चा Deny फक्त s3:DeleteObject बद्दल आहे, म्हणून वाचणे चालूच राहते.

🏁 तुम्ही आत्ताच काय सिद्ध केले

परवानग्या यादीनुसार चालतात: कोणीही policy न बदलता, तीच व्यक्ती group मध्ये येऊन किंवा जाऊन access मिळवते किंवा गमावते.

⚠️ नेहमीच्या चुका

"फक्त एवढ्या वेळेस" म्हणून policies थेट users ना जोडणे — ते कधीच एका वेळेपुरते राहत नाही
संपूर्ण team साठी एकच वाटून घेतलेला IAM user (audit trail नाही, सोडून जाणाऱ्यासाठी स्वच्छ प्रक्रिया नाही)
bucket policy च्या Principal मध्ये group टाकण्याचा प्रयत्न — groups हे principals नाहीत
root access keys अस्तित्वात असणेच; MFA शिवायचा root

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: auditors सुरुवातीलाच दोन प्रश्न विचारतात — "root user चे MFA दाखवा आणि त्याच्याकडे keys नाहीत हे दाखवा" आणि "परवानग्या व्यक्तींकडून नाही, तर groups किंवा roles कडून येतात हे दाखवा". दोन्ही सिद्ध करायला एकच CLI call पुरतो.

⏭️ पुढे

नियमावर नेमके काय लिहिलेले असते? Policies — प्रत्येक statement मध्ये असणारी चार fields.

git checkout lesson-03-policies

👥 Lesson 02 — Users, groups & root: cards and class lists

📍 You are here: Lesson 02 of 12 · Previous: lesson-01-why-iam · Next: lesson-03-policies

📦 What's in this branch

Lesson 01, plus the first identities: IAM users (aishwarya, katrina, dipika), a group (teachers) that carries the policies, and the root user you lock away. users() in iam/demo.py shows permissions following the list.

🧒 Explain like I'm 5

The ID office gives every grown-up in the school a card with their name on it — that is an IAM user. Writing "Aishwarya may open the library" on Aishwarya's own card is tiring: when a new teacher joins you write it again, and when one leaves you hunt for every card.

So the office keeps class lists 📋 instead. The rules are pinned to the list — "everyone on the teachers list may read reports" — and people just join or leave the list. Dipika joins teachers: she can read reports. She leaves: she cannot.

And the master key 🗝️ — the one that opens every door and was cut when the school was built — goes in the safe, with a second lock (MFA). That is the root user.

🗺️ Diagram

flowchart LR
    root["🗝️ root user<br/>MFA · no access keys · in the safe"]
    grp["📋 group: teachers<br/>read-reports · own-homework-folder"]
    a["🪪 aishwarya"] --> grp
    s["🪪 katrina"] --> grp
    k["🪪 dipika<br/>no groups"]
    grp -->|"1 policies apply to members"| ok["✅ s3:GetObject report"]
    k -.->|"2 nothing attached"| no["🚫 IMPLICIT DENY"]

🗺️ Drawn version + a lab: https://school-edh.pages.dev/iam/lesson-diagrams.html#l02

❓ What

IAM user — a long-lived identity in one account, with a console password and/or up to two access keys (AKIA…). Today's advice: people sign in through IAM Identity Center (lesson 10) and machines use roles (lessons 05–06); IAM users are for the few cases left.
IAM group — a list of users with policies attached. A group is not a principal: it cannot be named in a resource policy and cannot sign a request. Groups cannot contain groups. A user can be in up to 10 groups.
Effective permissions of a user = the policies on the user plus the policies of every group they are in (then evaluated as in lesson 04).
Root user — enable MFA, delete any root access keys, keep contact details current, and use it only for the few tasks that need it (e.g. closing the account, changing some account settings).

🤔 Why

Permissions pinned to people drift: someone changes team and keeps the old rights, a leaver keeps a key. Permissions pinned to lists are reviewed once and apply to everyone on them. And a root user in daily use is a master key in a pocket.

🔧 How (in this repo)

In iam/demo.py, GROUPS maps teachers to two policies and MEMBERS says who is on the list; policies_of(name) gathers a user's policies through their groups. users() asks the same question for three people, then adds dipika to the list and asks again.

🧪 Try it

python3 iam/demo.py users
python3 - <<'EOF'
import sys; sys.path.insert(0, "iam"); from evaluate import decide, load
groups = {"teachers": ["read-reports", "own-homework-folder"], "exam-board": ["deny-delete-reports"]}
def policies(*gs): return [(p, load(p)) for g in gs for p in groups[g]]
dipika, notes = "arn:aws:iam::111122223333:user/dipika", "arn:aws:s3:::school-homework/dipika/notes.txt"
print("no groups         ", decide(dipika, "s3:PutObject", notes, identity=policies())[0])
print("teachers          ", decide(dipika, "s3:PutObject", notes, identity=policies("teachers"))[0])
print("teachers + exams  ", decide(dipika, "s3:GetObject", "arn:aws:s3:::school-reports/term1.pdf", identity=policies("teachers", "exam-board"))[0])
EOF

On a real account (needs the AWS CLI and credentials):

aws iam create-group --group-name teachers
aws iam create-policy --policy-name read-reports --policy-document file://iam/policies/read-reports.json
aws iam attach-group-policy --group-name teachers --policy-arn arn:aws:iam::111122223333:policy/read-reports
aws iam create-user --user-name dipika
aws iam add-user-to-group --user-name dipika --group-name teachers
aws iam list-groups-for-user --user-name dipika
aws iam get-account-summary --query 'SummaryMap.AccountMFAEnabled'    # 1 = root has MFA

✅ Verify — what you should see

users prints ✅ ALLOW for aishwarya and katrina (identity policy read-reports#ReadReports allows it), 🚫 IMPLICIT DENY for dipika with no groups, then ✅ ALLOW once dipika joins teachers. Your snippet prints IMPLICIT DENY, ALLOW, ALLOW — joining a second group adds rules; the exam board's Deny is only about s3:DeleteObject, so reading still works.

🏁 What you just proved

Permissions follow the list: the same person gets or loses access by joining or leaving a group, without anyone editing a policy.

⚠️ Common mistakes

attaching policies straight to users "just this once" — it never stays once
one shared IAM user for a whole team (no audit trail, no clean leaver process)
trying to put a group in a bucket policy's Principal — groups are not principals
root access keys that exist at all; root without MFA

🏭 Why this matters in production: auditors ask two questions early — "show me the root user's MFA and that it has no keys" and "show me that permissions come from groups or roles, not from individuals". Both are one CLI call to prove.

⏭️ Next

What exactly is written on a rule? Policies — the four fields every statement has.

git checkout lesson-03-policies

← Previouswhy iam Next →policies

This page is the lesson's README from the lesson-02-users-groups-root branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.