Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Budujesz małą konfigurację IAM w chmurze na własnym komputerze: tworzysz użytkowników z polityką najmniejszych uprawnień, obserwujesz działanie domyślnej odmowy i jawnego deny, ponownie wykorzystujesz politykę zarządzaną przez grupę, nadajesz użytkownikowi poświadczenia tymczasowe przez przyjęcie roli i rotujesz klucz dostępu. Wszystko działa na lokalnym emulatorze, więc nie możesz niczego zepsuć naprawdę ani wydać ani grosza.
## Cele nauki
- Uwierzytelniać się jako różne podmioty i odróżniać niepowodzenie uwierzytelniania od niepowodzenia autoryzacji.
- Napisać politykę JSON z najmniejszymi uprawnieniami i przetestować dozwolone i odrzucone żądanie dla każdej instrukcji.
- Wykazać, że jawny deny uchyla allow.
- Ponownie wykorzystać uprawnienia przez politykę zarządzaną przypisaną do grupy.
- Przyjąć rolę, aby uzyskać poświadczenia tymczasowe (klucz ASIA i token sesji), i porównać tożsamość oraz uprawnienia przed i po.
- Zrotować klucz dostępu bez przerywania dostępu i przejrzeć klucze wraz z ich ostatnim użyciem.
## Wymagania wstępne
- Podman 4 lub nowszy na Linuxie, w trybie rootless, bez `sudo` (przetestowano na Podmanie 5.8). Docker też działa, jeśli w poleceniach zamienisz `podman` na `docker`.
- Obrazy pobierane przy pierwszym użyciu (łącznie około 900 MB miejsca na dysku): `docker.io/motoserver/moto:5.2.4` (serwer) i `docker.io/amazon/aws-cli:2.38.0` (klient).
- Wolny port TCP `9100` na `127.0.0.1`.
- Bez konta w chmurze, bez karty kredytowej i bez dostępu do Internetu po pobraniu obrazów.
- [Lekcja o IAM w chmurze](lesson.pl.md) z tego modułu.
> [!WARNING]
> Laboratorium jest bezpłatne i lokalne. Serwer nasłuchuje wyłącznie na `127.0.0.1`. „Klucze”, które tworzysz, to losowe ciągi znaków dla emulatora i nigdzie indziej nic nie znaczą; laboratorium zapisuje je w zwykłych plikach, aby skrócić kroki, czego z prawdziwymi poświadczeniami **nigdy** nie wolno robić. Zmiany pozostają w jednym folderze (`~/iam-lab`), jednym kontenerze i, opcjonalnie, dwóch obrazach, wszystko usuwane na końcu.
> [!NOTE]
> **Dlaczego API zgodne z AWS?** Laboratorium używa API AWS IAM, STS i S3, ponieważ są de facto standardem: rozumie je większość poradników, narzędzi, modułów Terraform i usług magazynowania zgodnych z S3 u innych dostawców, a emulatory open source pozwalają ćwiczyć za darmo. Inni dostawcy różnią się składnią i słownictwem (OpenStack Keystone z użytkownikami, projektami i tokenami; przypisania ról w Azure w danym zakresie; role Google Cloud powiązane z członkami na zasobie), ale łączą je pojęcia, które tu ćwiczysz: podmioty, domyślna odmowa, najmniejsze uprawnienia i poświadczenia tymczasowe.
> [!NOTE]
> **Ograniczenia emulatora.** [Moto](https://docs.getmoto.org/) to emulator, a nie prawdziwa chmura, i implementuje tylko część IAM. W tej konfiguracji (Moto 5.2.4) `Allow` i `Deny` na akcjach i zasobach są egzekwowane dla IAM, STS i S3, co wystarcza w laboratorium. Te zachowania prawdziwej chmury **nie** są odtwarzane, więc nie spodziewaj się ich i nie polegaj na nich: bloki `Condition` są ignorowane (warunek MFA lub IP zawsze „przechodzi”); dezaktywacja klucza dostępu go nie blokuje; wygaśnięcie poświadczeń tymczasowych nie jest weryfikowane; `iam simulate-principal-policy` kończy się błędem serwera; a presigned URL-e i żądania anonimowe kończą się błędem serwera, gdy uwierzytelnianie jest wymuszone. W prawdziwej chmurze wszystko to działa.
## Architektura
<figure class="diagram" style="--dg-w: 1080px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1080 440" width="1080" height="440" role="img" aria-labelledby="iam-lab-architecture-pl-title iam-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="iam-lab-architecture-pl-title">Architektura labu: kontener AWS CLI rozmawiający z lokalnym emulatorem IAM Moto</title>
<desc id="iam-lab-architecture-pl-desc">Na twoim komputerze z Linuksem i Podmanem bez roota terminal uruchamia funkcje powłoki z lab.sh w folderze ~/iam-lab, który zawiera też pliki JSON z politykami oraz folder keys z kluczami wyłącznie do labu. Każde polecenie aws uruchamia kontener AWS CLI v2, obraz amazon/aws-cli:2.38.0, startowany z run --rm, z ~/iam-lab zamontowanym w /work. CLI wysyła podpisane żądania HTTP na 127.0.0.1 port 9100, mapowany na port 5000 kontenera lab-iam-moto z Moto 5.2.4, emulatorem API AWS, który wymusza uwierzytelnianie po pierwszych 3 wywołaniach. Moto trzyma stan w pamięci: użytkowników admin, bob, carol i dave, grupę analysts, rolę reader, politykę zarządzaną reports-reader i bucket lab-data.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1079" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="1040" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój komputer: Linux z Podmanem bez roota</text></g>
<rect class="dg-card" x="44" y="66" width="250" height="120" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 82) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="102" y="103" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Terminal</text>
<text x="62" y="134" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">use bob</text>
<text x="62" y="154" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">aws s3api get-object ...</text>
<text x="62" y="174" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">funkcje powłoki z lab.sh</text>
<rect class="dg-card" x="44" y="250" width="250" height="132" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 266) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="102" y="287" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/iam-lab</text>
<text x="62" y="318" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">lab.sh (funkcje)</text>
<text x="62" y="338" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">keys/ (tylko klucze labu)</text>
<text x="62" y="358" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">*.json (polityki)</text>
<g class="dg-l1"><rect class="dg-tint" x="340" y="60" width="290" height="150" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(356 73) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="382" y="87" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Podman: AWS CLI (run --rm)</text></g>
<rect class="dg-card" x="356" y="100" width="258" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(372 116) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="414" y="137" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">AWS CLI v2</text></g>
<text x="374" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">amazon/aws-cli:2.38.0</text>
<text x="374" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">montuje ~/iam-lab w /work</text>
<g class="dg-l7"><rect class="dg-tint" x="740" y="60" width="300" height="340" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(756 73) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="782" y="87" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Podman: lab-iam-moto</text></g>
<rect class="dg-card" x="756" y="100" width="268" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(772 116) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g></g>
<g class="dg-l7"><text x="814" y="137" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Moto 5.2.4</text></g>
<text x="774" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">emulator API AWS :5000</text>
<text x="774" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">auth wymuszane po 3 wywołaniach</text>
<text x="760" y="226" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="700" letter-spacing="1.2">STAN W PAMIĘCI</text>
<g class="dg-l1"><rect class="dg-solid" x="758" y="240" width="110" height="26" rx="13" fill="#0369a1"/><text x="813" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">użytk. admin</text></g>
<g class="dg-l1"><rect class="dg-solid" x="874" y="240" width="96" height="26" rx="13" fill="#0369a1"/><text x="922" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">użytk. bob</text></g>
<g class="dg-l1"><rect class="dg-solid" x="758" y="272" width="110" height="26" rx="13" fill="#0369a1"/><text x="813" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">użytk. carol</text></g>
<g class="dg-l1"><rect class="dg-solid" x="874" y="272" width="103" height="26" rx="13" fill="#0369a1"/><text x="925.5" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">użytk. dave</text></g>
<g class="dg-l2"><rect class="dg-solid" x="758" y="304" width="125" height="26" rx="13" fill="#15803d"/><text x="820.5" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">grupa analysts</text></g>
<g class="dg-l3"><rect class="dg-solid" x="889" y="304" width="103" height="26" rx="13" fill="#b45309"/><text x="940.5" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">rola reader</text></g>
<g class="dg-l7"><rect class="dg-solid" x="758" y="336" width="190" height="26" rx="13" fill="#6d28d9"/><text x="853" y="353.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">polityka reports-reader</text></g>
<g class="dg-l4"><rect class="dg-solid" x="758" y="368" width="132" height="26" rx="13" fill="#c2410c"/><text x="824" y="385.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">bucket lab-data</text></g>
<path class="dg-line" d="M296 130H332" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M327 124l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><path class="dg-stroke" d="M634 148H732" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M727 142l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="630.92" y="136" width="108.16" height="24" rx="12" fill="#ffffff"/><text x="685" y="152.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">podpisany HTTP</text></g>
<text x="685" y="176" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9100</text>
<path class="dg-line" d="M296 320H485V218" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/>
<path class="dg-line" d="M479 225l6-8 6 8" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-bg-plain" x="414.82" y="278" width="140.36" height="24" rx="12" fill="#ffffff"/><text x="485" y="294.5" font-size="11.5" class="dg-muted" fill="#5c5c68" font-weight="600" text-anchor="middle">zamontowane w /work</text>
</svg></figure>
*Rysunek 1. Każde polecenie `aws` to krótkotrwały kontener klienta, który wysyła podpisane żądania do emulatora na `127.0.0.1:9100`; emulator trzyma użytkowników, polityki i dane w pamięci.*
## Kroki
### Krok 1 — Utwórz folder roboczy i uruchom emulator
Wszystkie pliki trafiają do jednego folderu, więc sprzątanie jest proste. Kontener serwera ma nazwę zaczynającą się od `lab-iam-`, a `INITIAL_NO_AUTH_ACTION_COUNT=3` każe Moto przyjąć pierwsze trzy wywołania API bez uwierzytelniania. Dokładnie tego potrzeba, aby uruchomić pierwszego administratora, bo nikt nie może podpisać żądania, dopóki nie istnieją użytkownik i klucz. Po trzecim wywołaniu każde żądanie musi być podpisane znanym kluczem i jest sprawdzane względem polityk.
```bash
mkdir -p ~/iam-lab && cd ~/iam-lab
podman run -d --name lab-iam-moto -p 127.0.0.1:9100:5000 \
-e INITIAL_NO_AUTH_ACTION_COUNT=3 docker.io/motoserver/moto:5.2.4
```
Oczekiwany wynik (identyfikator kontenera; Twój będzie inny):
```text
f97527afd13808739cf9b751e2d21b95469f2837c6cbb991e688d8f806244295
```
> [!IMPORTANT]
> Trzy darmowe wywołania to licznik na serwerze: wykonaj dokładnie kroki 3 do 5 w tej kolejności i nie uruchamiaj przed nimi innych poleceń `aws`. Jeśli pomylisz kolejność, usuń kontener i zacznij od nowa: `podman rm -f lab-iam-moto`, a potem powtórz ten krok. (Polecenie, które zawiedzie po Twojej stronie, zanim dotrze do serwera, na przykład przez literówkę w nazwie pliku, nie zużywa wywołania.)
### Krok 2 — Zdefiniuj funkcje pomocnicze
Utwórz mały plik z trzema funkcjami powłoki i załaduj go. To jedyne „narzędzie” w laboratorium. Przeczytaj go raz: jest krótki.
- `aws` uruchamia kontener AWS CLI v2 i kieruje go do emulatora. Przekazuje Twoje poświadczenia ze zmiennych środowiskowych, montuje bieżący folder w `/work`, aby działało `file://policy.json` (`:Z` ponownie etykietuje folder dla hostów z SELinux, takich jak Fedora), i używa stałego regionu.
- `use <name>` przełącza Twój terminal na tożsamość, której klucz jest zapisany w `keys/<name>`.
- `newkey <user>` tworzy klucz dostępu dla użytkownika i zapisuje go w `keys/<user>`.
```bash
cat > lab.sh <<'SCRIPT'
# Lab helpers: source this file in every terminal you use for the lab.
aws() { podman run --rm --network host -v "$PWD:/work:Z" -w /work -e AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY -e AWS_SESSION_TOKEN -e AWS_DEFAULT_REGION=us-east-1 -e AWS_PAGER= docker.io/amazon/aws-cli:2.38.0 --endpoint-url http://127.0.0.1:9100 "$@"; }
# use <name>: act as the user whose key is saved in ~/iam-lab/keys/<name>
use() { read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY < "$HOME/iam-lab/keys/$1"; export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY; unset AWS_SESSION_TOKEN; }
# newkey <user>: create an access key for <user> and save it (lab only: never store real keys in plain files)
newkey() { aws iam create-access-key --user-name "$1" --query 'AccessKey.[AccessKeyId,SecretAccessKey]' --output text > "$HOME/iam-lab/keys/$1"; }
SCRIPT
mkdir -p keys && chmod 700 keys
source lab.sh
```
Pierwsze polecenie `aws` pobiera obraz CLI (około 470 MB), więc jednorazowo chwilę trwa. Wykonuj `source ~/iam-lab/lab.sh` w każdym nowym terminalu, z folderu `~/iam-lab`.
### Krok 3 — Uruchom administratora (darmowe wywołania 1 do 3)
Emulator nie sprawdza poświadczeń pierwszych trzech wywołań, ale CLI nadal chce jakichś, więc używasz fikcyjnej pary `test` / `test`. Tworzysz użytkownika `admin`, dajesz mu politykę zezwalającą na wszystko i tworzysz jego klucz dostępu. Plik polityki ma kształt, który znasz z lekcji: wersja i jedna instrukcja.
```bash
export AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test
cat > admin-policy.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{ "Effect": "Allow", "Action": "*", "Resource": "*" }
]
}
JSON
aws iam create-user --user-name admin
aws iam put-user-policy --user-name admin --policy-name admin-all --policy-document file://admin-policy.json
newkey admin
```
Oczekiwany wynik (identyfikator użytkownika i data będą inne; `put-user-policy` i `newkey` nic nie wypisują):
```text
{
"User": {
"Path": "/",
"UserName": "admin",
"UserId": "c2ndbofy683n3gu2ii3r",
"Arn": "arn:aws:iam::123456789012:user/admin",
"CreateDate": "2026-11-07T18:58:03.515092+00:00"
}
}
```
Konto `123456789012` to stały identyfikator konta używany przez Moto. Ta szeroka polityka jest tylko dla tego jednego administratora laboratorium: z lekcji wiadomo, dlaczego `*` na `*` jest w prawdziwym życiu niebezpieczne.
### Krok 4 — Zaloguj się jako admin i zobacz niepowodzenie uwierzytelniania
Przełącz się na właśnie zapisany klucz. Od teraz każde żądanie jest podpisane i sprawdzane.
```bash
use admin
aws sts get-caller-identity
aws iam list-users --query 'Users[].UserName'
```
Oczekiwany wynik (identyfikator użytkownika będzie inny):
```text
{
"UserId": "c2ndbofy683n3gu2ii3r",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/admin"
}
[
"admin"
]
```
`get-caller-identity` to odpowiedź chmury na pytanie „kim jestem?” i działa dla każdej ważnej tożsamości bez dodatkowych uprawnień. Uruchamiaj je za każdym razem, gdy zastanawiasz się, której tożsamości używa Twój terminal. Teraz spróbuj jeszcze raz fikcyjnego klucza, który nie jest już znaną tożsamością:
```bash
AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws iam list-users
```
Oczekiwany wynik:
```text
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the ListUsers operation: The security token included in the request is invalid.
```
To niepowodzenie **uwierzytelniania**: serwer nie wie, kim jesteś. Zapamiętaj to: w kolejnych krokach zobaczysz `AccessDenied`, które jest innym problemem.
### Krok 5 — Utwórz bucket z dwoma folderami
Potrzebujesz czegoś do ochrony. Jako admin utwórz bucket `lab-data` i wgraj jeden nieszkodliwy „raport” i jeden „sekret”. Oba są fałszywym tekstem.
```bash
aws s3api create-bucket --bucket lab-data
echo "Q3 revenue: 42 (fake)" > q3.txt
echo "admin password: not-a-real-secret" > passwords.txt
aws s3 cp q3.txt s3://lab-data/reports/q3.txt --only-show-errors
aws s3 cp passwords.txt s3://lab-data/secret/passwords.txt --only-show-errors
aws s3 ls s3://lab-data --recursive
```
Oczekiwany wynik (znaczniki czasu będą inne):
```text
{
"Location": "/lab-data"
}
2026-11-07 18:58:18 22 reports/q3.txt
2026-11-07 18:58:19 34 secret/passwords.txt
```
### Krok 6 — Utwórz użytkownika bob z polityką najmniejszych uprawnień
Bob jest analitykiem, który ma czytać i zapisywać raporty i nic poza tym. Polityka ma dwie instrukcje, zapisane jak w lekcji: `ListBucket` dotyczy ARN bucketu, a `GetObject` i `PutObject` dotyczą obiektów w `reports/`.
```bash
cat > bob-policy.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "ReadWriteReports",
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject"],
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam create-user --user-name bob --query User.Arn
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy.json
newkey bob
```
Oczekiwany wynik:
```text
"arn:aws:iam::123456789012:user/bob"
```
`put-user-policy` tworzy **politykę inline (inline policy)**: żyje wewnątrz użytkownika i ma nazwę (`reports-rw`). Drugi rodzaj, politykę zarządzaną, poznasz w kroku 9.
### Krok 7 — Sprawdź, co Bob może, a czego nie może
Działaj jako Bob i wypróbuj osiem żądań. Przed uruchomieniem każdego przewidź odpowiedź: decyduje polityka, a nie szczęście.
```bash
use bob
aws sts get-caller-identity --query Arn --output text
echo "Q4 draft (fake)" > q4.txt
# 1. List the reports
aws s3api list-objects-v2 --bucket lab-data --prefix reports/ --query 'Contents[].Key'
# 2. Read a report
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-bob.txt --query ContentLength
cat q3-bob.txt
# 3. Write a report
aws s3api put-object --bucket lab-data --key reports/q4.txt --body q4.txt --query ETag
# 4. Write outside reports/
aws s3api put-object --bucket lab-data --key secret/q4.txt --body q4.txt
# 5. Read the secret
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
# 6. List all buckets
aws s3api list-buckets
# 7. Delete a report
aws s3api delete-object --bucket lab-data --key reports/q4.txt
# 8. Use IAM
aws iam list-users
```
Oczekiwany wynik (ETag będzie inny):
```text
arn:aws:iam::123456789012:user/bob
[
"reports/q3.txt"
]
22
Q3 revenue: 42 (fake)
"\"c32c8500d318ac0878b49cc441b6b837\""
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the ListBuckets operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the ListUsers operation: User: arn:aws:iam::123456789012:user/bob is not authorized to perform: iam:ListUsers
```
Żądania 1 do 3 pasują do `Allow`. Żądania 4 i 5 dotyczą `secret/`, na co nie zezwala żadna instrukcja. Żądanie 6 wymaga `s3:ListAllMyBuckets`, którego Bob nie ma. Żądanie 7, `DeleteObject`, nie należy do listy dozwolonych akcji. Wszystkie te przypadki to **domyślna odmowa**: żadna polityka nie powiedziała „nie”, po prostu nie ma żadnego „tak”. Zwróć uwagę, że każda odmowa to `AccessDenied`, a nie `InvalidClientTokenId`: Bob uwierzytelnił się bez problemu.
### Krok 8 — Rozszerz politykę zbyt szeroko, a potem dodaj jawny deny
Załóżmy, że ktoś „upraszcza” politykę Boba, wpisując `s3:*` na `reports/*`. Potem ograniczasz szkody jawnym deny dla usuwania. Zmiany polityk to zadanie administratora, więc przełącz się na admina i z powrotem.
```bash
use admin
cat > bob-policy-broad.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "EverythingInReports",
"Effect": "Allow",
"Action": "s3:*",
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy-broad.json
use bob
aws s3api delete-object --bucket lab-data --key reports/q4.txt && echo "delete succeeded"
aws s3api put-object --bucket lab-data --key reports/q4.txt --body q4.txt --query ETag
```
Oczekiwany wynik:
```text
delete succeeded
"\"c32c8500d318ac0878b49cc441b6b837\""
```
Zapisanie polityki o tej samej nazwie zastępuje starą. Bob może teraz usuwać: szerszy allow obejmuje `DeleteObject`. Plik `q4.txt` został wgrany ponownie, aby można było przetestować następny krok. Teraz dodaj do polityki trzecią instrukcję, jawny deny:
```bash
use admin
cat > bob-policy-deny.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "EverythingInReports",
"Effect": "Allow",
"Action": "s3:*",
"Resource": "arn:aws:s3:::lab-data/reports/*"
},
{
"Sid": "NeverDelete",
"Effect": "Deny",
"Action": "s3:DeleteObject",
"Resource": "*"
}
]
}
JSON
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy-deny.json
use bob
aws s3api delete-object --bucket lab-data --key reports/q4.txt
aws s3api get-object --bucket lab-data --key reports/q4.txt q4-back.txt --query ContentLength
aws s3api list-objects-v2 --bucket lab-data --query 'Contents[].Key'
```
Oczekiwany wynik:
```text
aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
16
[
"reports/q3.txt",
"reports/q4.txt",
"secret/passwords.txt"
]
```
Allow `s3:*` nadal pasuje do `DeleteObject`, ale jawny `Deny` wygrywa: usunięcie się nie udaje, a obiekt nadal istnieje (16 bajtów). Zwróć uwagę także na ostatni wynik: Bob może *wylistować* cały bucket, łącznie z nazwą `secret/passwords.txt`, ponieważ `ListBucket` zezwolono na ARN bucketu bez ograniczenia prefiksu. Nie może przeczytać pliku, ale dowiaduje się, że istnieje. W prawdziwej chmurze zawęża się to za pomocą `Condition` na prefiks klucza; emulator ignoruje warunki, więc tutaj nie da się tego wypróbować.
### Krok 9 — Wykorzystaj uprawnienia ponownie za pomocą polityki zarządzanej i grupy
Polityki inline są kopiowane dla każdego użytkownika. **Polityka zarządzana (managed policy)** to nazwany, wielokrotnego użytku dokument, który tworzy się raz i przypisuje wielu użytkownikom, grupom lub rolom. Utwórz politykę tylko do odczytu, przypisz ją do grupy `analysts` i dodaj do grupy nowego użytkownika, dave. Dave dostaje uprawnienia z grupy i nie ma własnej polityki.
```bash
use admin
cat > reports-reader.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam create-policy --policy-name reports-reader --policy-document file://reports-reader.json --query Policy.Arn
aws iam create-group --group-name analysts --query Group.Arn
aws iam attach-group-policy --group-name analysts --policy-arn arn:aws:iam::123456789012:policy/reports-reader
aws iam create-user --user-name dave --query User.Arn
aws iam add-user-to-group --group-name analysts --user-name dave
aws iam list-groups-for-user --user-name dave --query 'Groups[].GroupName'
newkey dave
```
Oczekiwany wynik:
```text
"arn:aws:iam::123456789012:policy/reports-reader"
"arn:aws:iam::123456789012:group/analysts"
"arn:aws:iam::123456789012:user/dave"
[
"analysts"
]
```
Przetestuj Dave'a:
```bash
use dave
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-dave.txt --query ContentLength
aws s3api put-object --bucket lab-data --key reports/dave.txt --body q4.txt
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
```
Oczekiwany wynik:
```text
22
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
```
Dave może czytać raporty, bo jego grupa ma politykę zarządzaną; nie może zapisywać ani czytać sekretu. Dodanie następnego analityka to jedno wywołanie `add-user-to-group`, a zmiana tego, co analitycy mogą robić, oznacza edycję jednej polityki. To właśnie RBAC w praktyce.
### Krok 10 — Przyjmij rolę, aby uzyskać poświadczenia tymczasowe
Carol potrzebuje dostępu do raportów tylko od czasu do czasu. Zamiast stałego uprawnienia tworzysz **rolę (role)** `reader`, którą może przyjąć. Rola ma **politykę zaufania (trust policy)** (kto może ją przyjąć) i **politykę uprawnień (permissions policy)** (co może robić; używasz ponownie `reports-reader.json`).
```bash
use admin
aws iam create-user --user-name carol --query User.Arn
newkey carol
cat > reader-trust.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:user/carol" },
"Action": "sts:AssumeRole"
}
]
}
JSON
aws iam create-role --role-name reader --assume-role-policy-document file://reader-trust.json --query Role.Arn
aws iam put-role-policy --role-name reader --policy-name read-reports --policy-document file://reports-reader.json
cat > carol-assume.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::123456789012:role/reader"
}
]
}
JSON
aws iam put-user-policy --user-name carol --policy-name may-assume-reader --policy-document file://carol-assume.json
```
Oczekiwany wynik:
```text
"arn:aws:iam::123456789012:user/carol"
"arn:aws:iam::123456789012:role/reader"
```
> [!NOTE]
> Ostatnia polityka pozwala Carol wywołać `sts:AssumeRole` dla tej jednej roli. Prawdziwy AWS akceptuje politykę zaufania wskazującą użytkownika z tego samego konta bez niej; emulator wymaga obu, więc dodajesz ją tutaj. Wiele zespołów i tak ją dodaje, aby uprawnienie było widoczne na użytkowniku.
Teraz działaj jako Carol. Najpierw spróbuj odczytać raport bezpośrednio: nie ma do tego własnych uprawnień. Potem przyjmij rolę. Wiersz `read` pobiera z odpowiedzi trzy wartości tymczasowe (identyfikator klucza, sekret, token sesji) i wstawia je do zmiennych środowiskowych.
```bash
use carol
aws sts get-caller-identity
aws s3api get-object --bucket lab-data --key reports/q3.txt x.txt
read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(
aws sts assume-role --role-arn arn:aws:iam::123456789012:role/reader \
--role-session-name carol-lab --duration-seconds 900 \
--query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]' --output text)
export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
echo "key id starts with: ${AWS_ACCESS_KEY_ID:0:4} session token length: ${#AWS_SESSION_TOKEN}"
```
Oczekiwany wynik (identyfikator użytkownika i długość tokenu będą inne):
```text
{
"UserId": "2lahxwq9nou7k0ox8yzp",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/carol"
}
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
key id starts with: ASIA session token length: 356
```
Klucz zaczyna się teraz od `ASIA`, prefiksu poświadczeń tymczasowych (klucze długotrwałe zaczynają się od `AKIA`), a token sesji jest częścią każdego żądania. Porównaj tożsamości i uprawnienia:
```bash
aws sts get-caller-identity
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-role.txt --query ContentLength
aws s3api put-object --bucket lab-data --key reports/carol.txt --body q4.txt
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
```
Oczekiwany wynik:
```text
{
"UserId": "AROARZPUZDIKOPOZ53WR2:carol-lab",
"Account": "123456789012",
"Arn": "arn:aws:sts::123456789012:assumed-role/reader/carol-lab"
}
22
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
```
Carol jest teraz `assumed-role/reader/carol-lab`: obowiązują uprawnienia roli (odczyt raportów i nic więcej), a jej własne są zawieszone. Nazwa sesji `carol-lab` pojawiłaby się w dziennikach audytu, więc nadal można ustalić, kto działał. Te poświadczenia mają ważność 900 sekund (15 minut) i po tym czasie przestałyby działać; emulator nie egzekwuje wygaśnięcia (zob. uwagę o emulatorze), ale prawdziwa chmura tak. Wróć do własnej tożsamości Carol: `use` czyści token sesji.
```bash
use carol
aws sts get-caller-identity --query Arn --output text
```
Oczekiwany wynik:
```text
arn:aws:iam::123456789012:user/carol
```
### Krok 11 — Zrotuj klucz dostępu
Długotrwałe klucze należy regularnie wymieniać, bez przerwy w działaniu. Bezpieczna kolejność: utworzyć drugi klucz, przełączyć aplikację na niego, potwierdzić, że stary klucz nie jest już używany, i usunąć stary. Użytkownik może mieć naraz dwa klucze, co to umożliwia. Zrotuj klucz Boba.
```bash
use admin
cp keys/bob keys/bob.old
read -r OLDKEY _ < keys/bob.old
aws iam list-access-keys --user-name bob --query 'AccessKeyMetadata[].[AccessKeyId,Status]' --output text
newkey bob
aws iam list-access-keys --user-name bob --query 'length(AccessKeyMetadata)'
```
Oczekiwany wynik (identyfikatory kluczy będą inne; każdy identyfikator ma 20 znaków):
```text
AKIAIOSFODNN7EXAMPLE Active
2
```
Bob ma teraz dwa aktywne klucze. Oba działają, więc możesz przenosić jego aplikacje na nowy (`keys/bob`) we własnym tempie:
```bash
use bob; aws sts get-caller-identity --query Arn --output text
use bob.old; aws sts get-caller-identity --query Arn --output text
```
Oczekiwany wynik:
```text
arn:aws:iam::123456789012:user/bob
arn:aws:iam::123456789012:user/bob
```
Gdy nic już nie używa starego klucza, usuń go i potwierdź, że działa tylko nowy:
```bash
use admin
aws iam delete-access-key --user-name bob --access-key-id "$OLDKEY"
aws iam list-access-keys --user-name bob --query 'length(AccessKeyMetadata)'
use bob.old; aws sts get-caller-identity
use bob; aws sts get-caller-identity --query Arn --output text
```
Oczekiwany wynik:
```text
1
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the GetCallerIdentity operation: The security token included in the request is invalid.
arn:aws:iam::123456789012:user/bob
```
Stary klucz zawodzi na etapie **uwierzytelniania**, dokładnie jak fikcyjny klucz w kroku 4.
> [!NOTE]
> W prawdziwej chmurze można też najpierw ustawić klucz na `Inactive` (`aws iam update-access-key --status Inactive`) i odczekać kilka dni, aby zobaczyć, co przestanie działać, zanim zostanie usunięty. Moto nie egzekwuje dezaktywacji, więc laboratorium przechodzi od razu do usuwania.
### Krok 12 — Przegląd: kto istnieje i kiedy używano kluczy?
Regularny przegląd dostępów zaczyna się od inwentarza. Wylistuj użytkowników, policz ich klucze i sprawdź, kiedy klucz był ostatnio używany i do jakiej usługi. Klucze, których nikt nie używał od miesięcy, są kandydatami do usunięcia.
```bash
use admin
aws iam list-users --query 'Users[].UserName' --output text
for u in admin bob carol dave; do echo -n "$u keys: "; aws iam list-access-keys --user-name $u --query 'length(AccessKeyMetadata)'; done
aws iam get-access-key-last-used --access-key-id "$(cut -f1 keys/bob)"
```
Oczekiwany wynik (data i kolejność będą inne):
```text
admin bob dave carol
admin keys: 1
bob keys: 1
carol keys: 1
dave keys: 1
{
"UserName": "bob",
"AccessKeyLastUsed": {
"LastUsedDate": "2026-11-07T18:59:40.119388+00:00",
"ServiceName": "sts",
"Region": "us-east-1"
}
}
```
W prawdziwej chmurze w tym miejscu otwiera się także dziennik audytu (na przykład CloudTrail) i przegląda wywołania wykonane każdą tożsamością.
## Weryfikacja
Uruchom tę kontrolę. Próbuje każdego żądania i porównuje wynik (`allowed` lub `denied`) z tym, co powinny dać polityki. Każdy wiersz musi zaczynać się od `PASS`.
```bash
check() { local want=$1 label=$2; shift 2; if "$@" >/dev/null 2>&1; then got=allowed; else got=denied; fi; if [ "$got" = "$want" ]; then echo "PASS $label"; else echo "FAIL $label (got $got)"; fi; }
use bob
check allowed "bob: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check allowed "bob: write reports/q5.txt" aws s3api put-object --bucket lab-data --key reports/q5.txt --body q4.txt
check denied "bob: write secret/q5.txt" aws s3api put-object --bucket lab-data --key secret/q5.txt --body q4.txt
check denied "bob: delete reports/q5.txt" aws s3api delete-object --bucket lab-data --key reports/q5.txt
check denied "bob: list all buckets" aws s3api list-buckets
use dave
check allowed "dave: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check denied "dave: write reports/d.txt" aws s3api put-object --bucket lab-data --key reports/d.txt --body q4.txt
use carol
check denied "carol: read reports/q3.txt directly" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(aws sts assume-role --role-arn arn:aws:iam::123456789012:role/reader --role-session-name carol-verify --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]' --output text)
export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
check allowed "carol as reader: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check denied "carol as reader: write reports/c.txt" aws s3api put-object --bucket lab-data --key reports/c.txt --body q4.txt
use bob.old
check denied "bob's old key: any call" aws sts get-caller-identity
```
Oczekiwany wynik:
```text
PASS bob: read reports/q3.txt
PASS bob: write reports/q5.txt
PASS bob: write secret/q5.txt
PASS bob: delete reports/q5.txt
PASS bob: list all buckets
PASS dave: read reports/q3.txt
PASS dave: write reports/d.txt
PASS carol: read reports/q3.txt directly
PASS carol as reader: read reports/q3.txt
PASS carol as reader: write reports/c.txt
PASS bob's old key: any call
```
Kontrola `denied` przechodzi przy dowolnym niepowodzeniu, więc obejrzyj też ręcznie jedną odmowę (krok 7) i upewnij się, że to `AccessDenied`, a nie błąd połączenia.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9100/"` | Kontener serwera nie działa albo port 9100 zajmuje coś innego. | `podman ps -a --filter name=lab-iam-` i `podman logs lab-iam-moto`. Jeśli port jest zajęty, zatrzymaj tamten program. Jeśli trzeba było zacząć od nowa, powtórz kroki 3 do 12. |
| `InvalidClientTokenId` przy poleceniu, które powinno działać | Terminal używa złego klucza: fikcyjnego `test` po trzech darmowych wywołaniach, usuniętego klucza albo powłoki, w której nigdy nie uruchomiono `use`. | Uruchom `use <name>` i sprawdź za pomocą `aws sts get-caller-identity`. Jeśli kolejność uruchomienia była błędna, wykonaj `podman rm -f lab-iam-moto`, powtórz krok 1 i wykonaj kroki 3 do 5 w kolejności. |
| `Unable to locate credentials` (`NoCredentials`) | Nowy terminal bez funkcji pomocniczych ani poświadczeń. | `cd ~/iam-lab && source lab.sh && use admin`. |
| `Unable to load paramfile file://...: Permission denied` | SELinux blokuje zamontowany folder albo funkcję `aws` skopiowano bez `:Z`. | Sprawdź, czy opcja `-v "$PWD:/work:Z"` jest nienaruszona i czy działasz z `~/iam-lab`. |
| `AccessDenied` przy żądaniu, które miało działać | Polityka nie pasuje do akcji lub zasobu, zwykle przez pomylenie ARN bucketu z ARN obiektu albo przez starą politykę inline. | `aws iam get-user-policy --user-name bob --policy-name reports-rw` jako admin i porównaj akcję oraz ARN z żądaniem. |
| `MalformedPolicyDocument: Syntax errors in policy` | Nieprawidłowy JSON w pliku polityki: brakujący przecinek, cudzysłów lub nawias. | Sprawdź plik, na przykład poleceniem `python3 -m json.tool bob-policy.json`. |
| `Unknown options` lub błąd parsowania przy `--query` i `--output text` | `--query`, które zwraca obiekt, a nie listę ani ciąg znaków, może zawieść w trybie tekstowym. | Użyj `--output json` albo zapytania zwracającego listę (`[...]`) lub pojedynczą wartość. |
## Wyzwanie (opcjonalne)
Utwórz użytkowniczkę `erin`, która może *tylko* czytać obiekty w `reports/2026/` i nie ma możliwości wylistowania ani odczytania czegokolwiek innego. Następnie napisz politykę, która wymagałaby dla niej także MFA, i wyjaśnij, dlaczego można ją napisać, ale nie można przetestować w tym laboratorium. Na koniec utwórz rolę `uploader`, którą carol może przyjąć, aby wgrywać obiekty do `reports/`, ale nigdy ich nie usuwać, i udowodnij to poleceniami z kroku 10.
## Sprzątanie
Zatrzymaj i usuń kontener serwera oraz skasuj folder laboratorium. Folder zawiera klucze laboratoryjne, polityki i pobrane pliki; emulator trzyma dane tylko w pamięci, więc usunięcie kontenera usuwa każdego użytkownika, politykę i obiekt.
```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
podman rm -f lab-iam-moto
cd ~ && rm -r ~/iam-lab
```
Oczekiwany wynik:
```text
lab-iam-moto
```
Oba obrazy zostają w lokalnym magazynie, dzięki czemu drugie uruchomienie startuje natychmiast. Aby zwolnić miejsce na dysku (około 900 MB), usuń także je. Jeśli planujesz laboratorium o magazynowaniu, które używa tego samego obrazu emulatora, zachowaj obraz Moto:
```bash
podman rmi docker.io/amazon/aws-cli:2.38.0 docker.io/motoserver/moto:5.2.4
```
Sprawdź, że nic nie zostało:
```bash
podman ps -a --filter name=lab-iam-
ls ~/iam-lab
```
Pierwsze polecenie powinno wypisać tylko wiersz nagłówka, a drugie powinno zgłosić, że folder nie istnieje. Funkcje `aws` i `use` znikają po zamknięciu terminala.
## Co już umiesz
- Uwierzytelnianie i autoryzacja zawodzą inaczej: nieznany lub usunięty klucz daje `InvalidClientTokenId`, a znana tożsamość bez pasującego `Allow` daje `AccessDenied`.
- Wszystko jest odrzucane, dopóki polityka na to nie zezwoli (domyślna odmowa), a `ListBucket` (ARN bucketu) i `GetObject` (ARN obiektu) wymagają różnych zasobów.
- Szeroki allow można ograniczyć jawnym `Deny`, a deny zawsze wygrywa.
- Polityka zarządzana przypisana do grupy daje każdemu członkowi te same uprawnienia z jednego miejsca.
- `AssumeRole` wymienia tożsamość użytkownika na tożsamość roli: klucze `ASIA` z tokenem sesji, tylko uprawnienia roli i nazwa sesji, która zostaje w śladzie audytu.
- Rotacja kluczy jest bezpieczna, bo użytkownik może mieć dwa klucze: utworzyć, przełączyć, sprawdzić, usunąć.
- Emulator to dobry sposób na naukę modelu, ale nie odtwarza wszystkiego (warunków, dezaktywacji i wygaśnięcia), więc te rzeczy testuj w prawdziwej chmurze.