A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## Objetivo
Construir uma pequena configuração de IAM na cloud no seu próprio computador: criar utilizadores com uma política de menor privilégio, observar a negação por omissão e o deny explícito em ação, reutilizar uma política gerida através de um grupo, dar credenciais temporárias a um utilizador que assume um role e rodar uma chave de acesso. Tudo corre num emulador local, pelo que não se pode estragar nada de real nem gastar um cêntimo.
## Objetivos
- Autenticar-se como diferentes principais e distinguir uma falha de autenticação de uma falha de autorização.
- Escrever uma política JSON de menor privilégio e testar um pedido permitido e um negado para cada declaração.
- Mostrar que um deny explícito se sobrepõe a um allow.
- Reutilizar permissões através de uma política gerida associada a um grupo.
- Assumir um role para obter credenciais temporárias (chave ASIA e token de sessão) e comparar a identidade e as permissões antes e depois.
- Rodar uma chave de acesso sem interromper o acesso e rever as chaves com a respetiva última utilização.
## Pré-requisitos
- Podman 4 ou posterior em Linux, sem privilégios de root, sem `sudo` (testado com Podman 5.8). O Docker funciona se se substituir `podman` por `docker` nos comandos.
- Imagens descarregadas na primeira utilização (cerca de 900 MB de disco no total): `docker.io/motoserver/moto:5.2.4` (o servidor) e `docker.io/amazon/aws-cli:2.38.0` (o cliente).
- Porta TCP `9100` livre em `127.0.0.1`.
- Sem conta na cloud, sem cartão de crédito e sem acesso à Internet depois de as imagens estarem descarregadas.
- [A lição de IAM na cloud](lesson.pt.md) deste módulo.
> [!WARNING]
> O laboratório é gratuito e local. O servidor escuta apenas em `127.0.0.1`. As "chaves" que se criam são cadeias aleatórias para um emulador e não significam nada em mais lado nenhum; o laboratório guarda-as em ficheiros simples para manter os passos curtos, o que **nunca** deve ser feito com credenciais reais. As alterações ficam dentro de uma pasta (`~/iam-lab`), de um contentor e, opcionalmente, de duas imagens, que são todos removidos no final.
> [!NOTE]
> **Porquê APIs compatíveis com a AWS?** O laboratório usa as APIs IAM, STS e S3 da AWS porque são a norma de facto: a maioria dos tutoriais, ferramentas, módulos do Terraform e serviços de armazenamento compatíveis com S3 de outros fornecedores compreendem-nas, e os emuladores de código aberto permitem praticar de graça. Outros fornecedores diferem na sintaxe e no vocabulário (o OpenStack Keystone com utilizadores, projetos e tokens; o Azure com atribuições de roles num âmbito; o Google Cloud com roles associados a membros num recurso), mas partilham os conceitos que aqui se praticam: principais, negação por omissão, menor privilégio e credenciais temporárias.
> [!NOTE]
> **Limites do emulador.** O [Moto](https://docs.getmoto.org/) é um emulador, não a cloud real, e implementa apenas parte do IAM. Nesta configuração (Moto 5.2.4), `Allow` e `Deny` em ações e recursos são aplicados para IAM, STS e S3, que é o que o laboratório precisa. Estes comportamentos da cloud real **não** são reproduzidos, pelo que não se deve esperá-los nem contar com eles: os blocos `Condition` são ignorados (uma condição de MFA ou de IP "passa" sempre); desativar uma chave de acesso não a bloqueia; a expiração das credenciais temporárias não é verificada; `iam simulate-principal-policy` falha com um erro de servidor; e os URLs pré-assinados e os pedidos anónimos falham com um erro de servidor quando a autenticação é imposta. Numa cloud real, tudo isto funciona.
## Arquitetura
<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-pt-title iam-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="iam-lab-architecture-pt-title">Arquitetura do lab: contentor AWS CLI a comunicar com um emulador IAM Moto local</title>
<desc id="iam-lab-architecture-pt-desc">No seu computador Linux com Podman sem root, um terminal executa funções de shell de lab.sh na pasta ~/iam-lab, que contém também os ficheiros JSON de políticas e uma pasta keys com chaves apenas para o lab. Cada comando aws executa o contentor do AWS CLI v2, imagem amazon/aws-cli:2.38.0, iniciado com run --rm, com ~/iam-lab montada em /work. O CLI envia pedidos HTTP assinados para 127.0.0.1 porta 9100, mapeada para a porta 5000 do contentor lab-iam-moto, que executa o Moto 5.2.4, um emulador da API da AWS que exige autenticação a partir das 3 primeiras chamadas. O Moto guarda o seu estado em memória: os utilizadores admin, bob, carol e dave, o grupo analysts, o role reader, a política gerida reports-reader e o 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">O seu computador: Linux com Podman sem root</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">funções de shell de 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 (funções)</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/ (só chaves do lab)</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 (políticas)</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">monta ~/iam-lab em /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">emulador de API AWS :5000</text>
<text x="774" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">auth exigida após 3 chamadas</text>
<text x="760" y="226" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="700" letter-spacing="1.2">ESTADO EM MEMÓRIA</text>
<g class="dg-l1"><rect class="dg-solid" x="758" y="240" width="103" height="26" rx="13" fill="#0369a1"/><text x="809.5" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. admin</text></g>
<g class="dg-l1"><rect class="dg-solid" x="867" y="240" width="89" height="26" rx="13" fill="#0369a1"/><text x="911.5" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. bob</text></g>
<g class="dg-l1"><rect class="dg-solid" x="758" y="272" width="103" height="26" rx="13" fill="#0369a1"/><text x="809.5" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. carol</text></g>
<g class="dg-l1"><rect class="dg-solid" x="867" y="272" width="96" height="26" rx="13" fill="#0369a1"/><text x="915" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. 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">grupo 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">role 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">política 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="634.14" y="136" width="101.72" 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">HTTP assinado</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="424.48" y="278" width="121.04" 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">montado em /work</text>
</svg></figure>
*Figura 1. Cada comando `aws` é um contentor cliente de curta duração que envia pedidos assinados ao emulador em `127.0.0.1:9100`; o emulador guarda em memória os utilizadores, as políticas e os dados.*
## Passos
### Passo 1 — Criar a pasta de trabalho e iniciar o emulador
Todos os ficheiros ficam numa só pasta, para a limpeza ser fácil. O contentor do servidor tem um nome que começa por `lab-iam-`, e `INITIAL_NO_AUTH_ACTION_COUNT=3` diz ao Moto para aceitar as suas três primeiras chamadas à API sem autenticação. É exatamente o que é preciso para arrancar o primeiro administrador, porque ninguém consegue assinar um pedido enquanto não existirem um utilizador e uma chave. Depois da terceira chamada, todos os pedidos têm de ser assinados por uma chave conhecida e são verificados contra as políticas.
```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
```
Saída esperada (um ID de contentor; o seu será diferente):
```text
f97527afd13808739cf9b751e2d21b95469f2837c6cbb991e688d8f806244295
```
> [!IMPORTANT]
> As três chamadas gratuitas são um contador no servidor: execute exatamente os Passos 3 a 5, pela ordem, e não execute outros comandos `aws` antes deles. Se trocar a ordem, remova o contentor e comece de novo: `podman rm -f lab-iam-moto` e repita este passo. (Um comando que falhe do seu lado antes de chegar ao servidor, por exemplo por um erro de escrita no nome de um ficheiro, não gasta uma chamada.)
### Passo 2 — Definir as funções auxiliares
Crie-se um pequeno ficheiro com três funções de shell e carregue-se. É a única "ferramenta" do laboratório. Leia-o uma vez: é curto.
- `aws` executa o contentor da AWS CLI v2 e aponta-o para o emulador. Passa as credenciais a partir de variáveis de ambiente, monta a pasta atual em `/work` para que `file://policy.json` funcione (`:Z` volta a etiquetar a pasta para anfitriões com SELinux, como o Fedora) e usa uma região fixa.
- `use <name>` muda o terminal para a identidade cuja chave está guardada em `keys/<name>`.
- `newkey <user>` cria uma chave de acesso para um utilizador e guarda-a em `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
```
O primeiro comando `aws` descarrega a imagem da CLI (cerca de 470 MB), pelo que demora um pouco, uma só vez. Execute `source ~/iam-lab/lab.sh` em cada terminal novo, a partir de `~/iam-lab`.
### Passo 3 — Arrancar o administrador (chamadas gratuitas 1 a 3)
O emulador não verifica as credenciais das três primeiras chamadas, mas a CLI continua a exigir algumas, pelo que se usa o par fictício `test` / `test`. Cria-se um utilizador `admin`, dá-se-lhe uma política que permite tudo e cria-se a sua chave de acesso. O ficheiro da política tem a forma que se viu na lição: uma versão e uma declaração.
```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
```
Saída esperada (o ID do utilizador e a data são diferentes; `put-user-policy` e `newkey` não mostram nada):
```text
{
"User": {
"Path": "/",
"UserName": "admin",
"UserId": "c2ndbofy683n3gu2ii3r",
"Arn": "arn:aws:iam::123456789012:user/admin",
"CreateDate": "2026-11-07T18:58:03.515092+00:00"
}
}
```
A conta `123456789012` é o ID de conta fixo que o Moto usa. Essa política abrangente destina-se apenas a este administrador do laboratório: viu-se na lição porque é que `*` em `*` é perigoso na vida real.
### Passo 4 — Iniciar sessão como admin e ver a autenticação falhar
Mude-se para a chave que acabou de ser guardada. A partir de agora, todos os pedidos são assinados e verificados.
```bash
use admin
aws sts get-caller-identity
aws iam list-users --query 'Users[].UserName'
```
Saída esperada (o ID do utilizador é diferente):
```text
{
"UserId": "c2ndbofy683n3gu2ii3r",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/admin"
}
[
"admin"
]
```
`get-caller-identity` é a resposta da cloud a "quem sou eu?" e funciona para qualquer identidade válida sem permissões adicionais. Execute-o sempre que tiver dúvidas sobre a identidade que o terminal está a usar. Tente-se agora de novo a chave fictícia, que já não é uma identidade conhecida:
```bash
AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws iam list-users
```
Saída esperada:
```text
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the ListUsers operation: The security token included in the request is invalid.
```
Esta é uma falha de **autenticação**: o servidor não sabe quem é. Tenha-a presente: nos passos seguintes vai ver `AccessDenied`, que é um problema diferente.
### Passo 5 — Criar um bucket com duas pastas
É preciso algo para proteger. Como admin, crie-se o bucket `lab-data` e carreguem-se um "relatório" inofensivo e um "segredo". Ambos são texto fictício.
```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
```
Saída esperada (as datas e horas são diferentes):
```text
{
"Location": "/lab-data"
}
2026-11-07 18:58:18 22 reports/q3.txt
2026-11-07 18:58:19 34 secret/passwords.txt
```
### Passo 6 — Criar o bob com uma política de menor privilégio
O Bob é um analista que tem de ler e escrever relatórios e mais nada. A política tem duas declarações, escritas como na lição: `ListBucket` aplica-se ao ARN do bucket, enquanto `GetObject` e `PutObject` se aplicam aos objetos em `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
```
Saída esperada:
```text
"arn:aws:iam::123456789012:user/bob"
```
`put-user-policy` cria uma **política inline**: vive dentro do utilizador e tem um nome (`reports-rw`). O outro tipo, uma política gerida, aparece no Passo 9.
### Passo 7 — Testar o que o Bob pode e não pode fazer
Atue-se como o Bob e experimentem-se oito pedidos. Para cada um, preveja-se a resposta antes de o executar: quem decide é a política, não a sorte.
```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
```
Saída esperada (o ETag é diferente):
```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
```
Os pedidos 1 a 3 coincidem com um `Allow`. Os pedidos 4 e 5 visam `secret/`, que nenhuma declaração permite. O pedido 6 precisa de `s3:ListAllMyBuckets`, que o Bob não tem. O pedido 7, `DeleteObject`, não consta da lista de ações permitidas. Tudo isto é a **negação por omissão**: nenhuma política disse "não", simplesmente não há nenhum "sim". Note-se que todas as recusas são `AccessDenied`, não `InvalidClientTokenId`: o Bob autenticou-se sem problemas.
### Passo 8 — Tornar a política demasiado abrangente e acrescentar um deny explícito
Suponha-se que alguém "simplifica" a política do Bob com `s3:*` em `reports/*`. Depois limita-se o estrago com um deny explícito sobre a eliminação. As alterações de políticas são trabalho de administrador, pelo que se muda para admin e volta-se atrás.
```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
```
Saída esperada:
```text
delete succeeded
"\"c32c8500d318ac0878b49cc441b6b837\""
```
Colocar uma política com o mesmo nome substitui a antiga. O Bob já pode eliminar: o allow mais abrangente cobre `DeleteObject`. Voltou a carregar-se `q4.txt` para se poder testar o passo seguinte. Acrescente-se agora uma terceira declaração, um deny explícito, à política:
```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'
```
Saída esperada:
```text
aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
16
[
"reports/q3.txt",
"reports/q4.txt",
"secret/passwords.txt"
]
```
O allow `s3:*` continua a coincidir com `DeleteObject`, mas o `Deny` explícito prevalece: a eliminação falha e o objeto continua lá (16 bytes). Repare-se também no último resultado: o Bob consegue *listar* todo o bucket, incluindo o nome `secret/passwords.txt`, porque `ListBucket` foi permitido no ARN do bucket sem limite de prefixo. Não consegue ler o ficheiro, mas fica a saber que existe. Numa cloud real, restringe-se isto com uma `Condition` sobre o prefixo da chave; o emulador ignora as condições, pelo que não se pode experimentar aqui.
### Passo 9 — Reutilizar permissões com uma política gerida e um grupo
As políticas inline são copiadas por utilizador. Uma **política gerida** é um documento com nome e reutilizável, que se cria uma vez e se associa a muitos utilizadores, grupos ou roles. Crie-se uma política só de leitura, associe-se a um grupo `analysts` e acrescente-se um utilizador novo, o dave, ao grupo. O Dave recebe as permissões do grupo e não tem nenhuma política própria.
```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
```
Saída esperada:
```text
"arn:aws:iam::123456789012:policy/reports-reader"
"arn:aws:iam::123456789012:group/analysts"
"arn:aws:iam::123456789012:user/dave"
[
"analysts"
]
```
Teste-se o Dave:
```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
```
Saída esperada:
```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
```
O Dave consegue ler relatórios porque o seu grupo tem a política gerida; não consegue escrever nem ler o segredo. Acrescentar o analista seguinte é uma única chamada `add-user-to-group`, e alterar o que os analistas podem fazer significa editar uma só política. Isto é RBAC na prática.
### Passo 10 — Assumir um role para obter credenciais temporárias
A Carol só precisa de acesso de leitura aos relatórios de vez em quando. Em vez de uma permissão permanente, cria-se um **role** `reader` que ela pode assumir. O role tem uma **política de confiança** (quem o pode assumir) e uma **política de permissões** (o que pode fazer; reutiliza-se `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
```
Saída esperada:
```text
"arn:aws:iam::123456789012:user/carol"
"arn:aws:iam::123456789012:role/reader"
```
> [!NOTE]
> A última política permite à Carol chamar `sts:AssumeRole` neste role específico. A AWS real aceita, por si só, uma política de confiança que indique um utilizador da mesma conta, sem esta política; o emulador exige ambas, pelo que se acrescenta aqui. Muitas equipas acrescentam-na de qualquer forma, para que a permissão fique visível no utilizador.
Atue-se agora como a Carol. Primeiro, tente-se ler diretamente um relatório: ela não tem permissão própria. Depois, assuma-se o role. A linha `read` extrai da resposta os três valores temporários (ID da chave, segredo, token de sessão) e coloca-os em variáveis de ambiente.
```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}"
```
Saída esperada (o ID do utilizador e o comprimento do token são diferentes):
```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
```
A chave começa agora por `ASIA`, o prefixo das credenciais temporárias (as chaves de longa duração começam por `AKIA`), e o token de sessão faz parte de cada pedido. Comparem-se as identidades e as permissões:
```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
```
Saída esperada:
```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
```
A Carol é agora `assumed-role/reader/carol-lab`: aplicam-se as permissões do role (ler relatórios, mais nada) e as dela ficam suspensas. O nome da sessão, `carol-lab`, apareceria nos registos de auditoria, pelo que ainda se consegue saber quem agiu. Estas credenciais foram pedidas por 900 segundos (15 minutos) e deixariam de funcionar passado esse tempo; o emulador não aplica a expiração (ver a nota sobre o emulador), mas uma cloud real aplica. Volte-se à identidade própria da Carol: `use` limpa o token de sessão.
```bash
use carol
aws sts get-caller-identity --query Arn --output text
```
Saída esperada:
```text
arn:aws:iam::123456789012:user/carol
```
### Passo 11 — Rodar uma chave de acesso
As chaves de longa duração devem ser substituídas com regularidade, sem interrupção do serviço. A ordem segura é: criar a segunda chave, passar a aplicação para ela, confirmar que a chave antiga já não é usada e eliminá-la. Um utilizador pode ter duas chaves em simultâneo, e é isso que torna a operação possível. Rode-se a chave do Bob.
```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)'
```
Saída esperada (os IDs das chaves são diferentes; cada ID tem 20 carateres):
```text
AKIAIOSFODNN7EXAMPLE Active
2
```
O Bob tem agora duas chaves ativas. Ambas funcionam, pelo que se podem passar as suas aplicações para a nova (`keys/bob`) ao ritmo que se quiser:
```bash
use bob; aws sts get-caller-identity --query Arn --output text
use bob.old; aws sts get-caller-identity --query Arn --output text
```
Saída esperada:
```text
arn:aws:iam::123456789012:user/bob
arn:aws:iam::123456789012:user/bob
```
Quando nada usar a chave antiga, elimine-se e confirme-se que só a nova funciona:
```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
```
Saída esperada:
```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
```
A chave antiga falha na **autenticação**, exatamente como a chave fictícia do Passo 4.
> [!NOTE]
> Numa cloud real, pode também definir-se primeiro uma chave como `Inactive` (`aws iam update-access-key --status Inactive`) e esperar alguns dias para ver o que deixa de funcionar antes de a eliminar. O Moto não aplica a desativação, pelo que o laboratório passa diretamente à eliminação.
### Passo 12 — Rever: quem existe e quando foram usadas as chaves?
Uma revisão de acessos regular começa por um inventário. Listem-se os utilizadores, contem-se as suas chaves e verifique-se quando uma chave foi usada pela última vez e para que serviço. As chaves que ninguém usa há meses são candidatas a eliminação.
```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)"
```
Saída esperada (a data e a ordem são diferentes):
```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"
}
}
```
Numa cloud real, é aqui que se abriria também o registo de auditoria (por exemplo, o CloudTrail) para ver as chamadas feitas com cada identidade.
## Verificação
Execute-se esta verificação. Experimenta cada pedido e compara o resultado (`allowed` ou `denied`) com o que as políticas devem produzir. Cada linha tem de começar por `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
```
Saída esperada:
```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
```
Uma verificação `denied` passa com qualquer falha, pelo que convém também observar manualmente uma recusa (Passo 7) e confirmar que diz `AccessDenied`, e não um erro de ligação.
## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9100/"` | O contentor do servidor não está a correr, ou a porta 9100 está ocupada por outra coisa. | `podman ps -a --filter name=lab-iam-` e `podman logs lab-iam-moto`. Se a porta estiver ocupada, pare-se o outro programa. Se tiver sido preciso recomeçar, refaçam-se os Passos 3 a 12. |
| `InvalidClientTokenId` num comando que devia funcionar | O terminal usa a chave errada: a chave fictícia `test` depois das três chamadas gratuitas, uma chave eliminada, ou uma shell que nunca executou `use`. | Execute-se `use <name>` e confirme-se com `aws sts get-caller-identity`. Se a ordem do arranque falhou, execute-se `podman rm -f lab-iam-moto`, repita-se o Passo 1 e façam-se os Passos 3 a 5 pela ordem. |
| `Unable to locate credentials` (`NoCredentials`) | Um terminal novo sem as funções auxiliares ou sem credenciais. | `cd ~/iam-lab && source lab.sh && use admin`. |
| `Unable to load paramfile file://...: Permission denied` | O SELinux bloqueia a pasta montada, ou a função `aws` foi copiada sem `:Z`. | Verifique-se que a opção `-v "$PWD:/work:Z"` está intacta e que se executa a partir de `~/iam-lab`. |
| `AccessDenied` num pedido que devia funcionar | A política não coincide com a ação ou o recurso, normalmente por causa do ARN do bucket versus o do objeto, ou de uma política inline antiga. | `aws iam get-user-policy --user-name bob --policy-name reports-rw` como admin, e comparem-se a ação e o ARN com o pedido. |
| `MalformedPolicyDocument: Syntax errors in policy` | JSON inválido no ficheiro da política: uma vírgula, aspas ou chaveta em falta. | Verifique-se o ficheiro, por exemplo com `python3 -m json.tool bob-policy.json`. |
| `Unknown options` ou um erro de análise com `--query` e `--output text` | Uma `--query` que devolve um objeto, e não uma lista ou uma cadeia, pode falhar em modo de texto. | Use-se `--output json`, ou uma consulta que devolva uma lista (`[...]`) ou um único valor. |
## Desafio (opcional)
Crie-se um utilizador `erin` que possa *apenas* ler objetos em `reports/2026/` e não tenha forma de listar nem de ler mais nada. Depois, escreva-se a política que lhe exigiria também MFA, e explique-se porque é que se pode escrever mas não testar neste laboratório. Por fim, crie-se um role `uploader` que a carol possa assumir para colocar objetos em `reports/` mas nunca para os eliminar, e prove-se com os comandos do Passo 10.
## Limpeza
Pare-se e remova-se o contentor do servidor, e apague-se a pasta do laboratório. A pasta contém as chaves, as políticas e os ficheiros descarregados do laboratório; o emulador guarda os seus dados apenas em memória, pelo que remover o contentor remove todos os utilizadores, políticas e objetos.
```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
podman rm -f lab-iam-moto
cd ~ && rm -r ~/iam-lab
```
Saída esperada:
```text
lab-iam-moto
```
As duas imagens permanecem no armazenamento local, para que uma segunda execução arranque instantaneamente. Para libertar o espaço em disco (cerca de 900 MB), removam-se também. Se pretender fazer o laboratório de armazenamento que usa a mesma imagem do emulador, mantenha a imagem do Moto:
```bash
podman rmi docker.io/amazon/aws-cli:2.38.0 docker.io/motoserver/moto:5.2.4
```
Verifique-se que não ficou nada:
```bash
podman ps -a --filter name=lab-iam-
ls ~/iam-lab
```
O primeiro comando deve mostrar apenas a linha de cabeçalho, e o segundo deve dizer que a pasta não existe. As funções `aws` e `use` desaparecem quando se fecha o terminal.
## O que aprendeu
- A autenticação e a autorização falham de forma diferente: uma chave desconhecida ou eliminada dá `InvalidClientTokenId`, uma identidade conhecida sem um `Allow` coincidente dá `AccessDenied`.
- Tudo é negado, a menos que uma política o permita (negação por omissão), e `ListBucket` (ARN do bucket) e `GetObject` (ARN do objeto) precisam de recursos diferentes.
- Um allow abrangente pode ser limitado por um `Deny` explícito, e o deny prevalece sempre.
- Uma política gerida associada a um grupo dá a todos os membros as mesmas permissões a partir de um único local.
- `AssumeRole` troca a identidade de um utilizador pela de um role: chaves `ASIA` com um token de sessão, apenas as permissões do role e um nome de sessão que fica no registo de auditoria.
- A rotação de chaves é segura porque um utilizador pode ter duas chaves: criar, passar, verificar, eliminar.
- Um emulador é uma boa forma de aprender o modelo, mas não reproduz tudo (condições, desativação e expiração), pelo que se devem testar essas coisas numa cloud real.