> ## Documentation Index
> Fetch the complete documentation index at: https://docs.basaltic.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Permissões de armazenamento

> Todas as ações do IAM em volumes, snapshots, buckets e objetos, além da camada de política de bucket que fica ao lado do IAM no lado do objeto.

O armazenamento é dois serviços sob um nome, e eles são protegidos de forma diferente. Volumes e snapshots são controlados apenas pelo IAM. Os buckets e objetos são controlados pelo IAM **e** pela própria política do bucket, e ambos podem decidir uma solicitação.

<Info>
  A referência da API mostra a ação na página própria de cada endpoint. Ambos vêm do mesmo lugar: a chamada de autorização no serviço, lida no momento da compilação.
</Info>

<a id="volumes-snapshots-and-policies" />

## Volumes, snapshots e políticas

| Ação e aventura | Chamada de telefone |
| - | - |
| `storage:ListVolumes` | `GET /v1/volumes` |
| `storage:CreateVolume` | `POST /v1/volumes` |
| `storage:GetVolume` | `GET /v1/volumes/{volume_id}` |
| `storage:UpdateVolume` | `PATCH /v1/volumes/{volume_id}` |
| `storage:DeleteVolume` | `DELETE /v1/volumes/{volume_id}` |
| `storage:ExtendVolume` | `POST /v1/volumes/{volume_id}/extend` |
| `storage:UpdateVolumePerformance` | `POST /v1/volumes/{volume_id}/performance` |
| `storage:ListVolumeTypes` | `GET /v1/volume-types` |
| `storage:ListSnapshots` | `GET /v1/snapshots` |
| `storage:CreateSnapshot` | `POST /v1/snapshots` |
| `storage:GetSnapshot` | `GET /v1/snapshots/{snapshot_id}` |
| `storage:UpdateSnapshot` | `PATCH /v1/snapshots/{snapshot_id}` |
| `storage:DeleteSnapshot` | `DELETE /v1/snapshots/{snapshot_id}` |
| `storage:ListSnapshotPolicies` | `GET /v1/snapshot-policies` |
| `storage:CreateSnapshotPolicy` | `POST /v1/snapshot-policies` |
| `storage:GetSnapshotPolicy` | `GET /v1/snapshot-policies/{policy_id}` |
| `storage:UpdateSnapshotPolicy` | `PATCH /v1/snapshot-policies/{policy_id}` |
| `storage:DeleteSnapshotPolicy` | `DELETE /v1/snapshot-policies/{policy_id}` |

Eles seguem os nomes dos endpoints e o recurso é o CRN do volume, snapshot ou política em que está sendo executada a ação.

<a id="buckets-and-objects" />

## Buckets e objetos

O lado do objeto recebe seus nomes de ação do S3, então vários deles **não** correspondem ao endpoint que eles protegem. Estes são os que vale a pena ler antes de escrever uma política.

| Ação e aventura | Chamada de telefone |
| - | - |
| `storage:ListAllMyBuckets` | `GET /v1/buckets` |
| `storage:CreateBucket` | `POST /v1/buckets` |
| `storage:HeadBucket` | `HEAD /v1/buckets/{bucket}` |
| `storage:DeleteBucket` | `DELETE /v1/buckets/{bucket}` |
| `storage:RestoreBucket` | `POST /v1/buckets/{bucket}/restore` |
| `storage:PutBucketDeletionProtection` | `PUT /v1/buckets/{bucket}/deletion-protection` |
| `storage:ListBucket` | `GET /v1/buckets/{bucket}/objects` |
| `storage:ListBucket` | `GET /v1/buckets/{bucket}/object-versions` |
| `storage:ListBucket` | `GET /v1/buckets/{bucket}/multipart-uploads` |
| `storage:GetObject` | `GET /v1/buckets/{bucket}/objects/{key}` |
| `storage:HeadObject` | `HEAD /v1/buckets/{bucket}/objects/{key}` |
| `storage:PutObject` | `PUT /v1/buckets/{bucket}/objects/{key}` |
| `storage:DeleteObject` | `DELETE /v1/buckets/{bucket}/objects/{key}` |
| `storage:PutObject` | cada chamada de upload multiparte |
| `storage:GetBucketPolicy` | `GET /v1/buckets/{bucket}/policy` |
| `storage:PutBucketPolicy` | `PUT /v1/buckets/{bucket}/policy` |
| `storage:DeleteBucketPolicy` | `DELETE /v1/buckets/{bucket}/policy` |
| `storage:GetBucketCORS` | `GET /v1/buckets/{bucket}/cors` |
| `storage:PutBucketCORS` | `PUT` **and** `DELETE /v1/buckets/{bucket}/cors` |
| `storage:GetBucketVersioning` | `GET /v1/buckets/{bucket}/versioning` |
| `storage:PutBucketVersioning` | `PUT /v1/buckets/{bucket}/versioning` |
| `storage:GetLifecycleConfiguration` | `GET /v1/buckets/{bucket}/lifecycle` |
| `storage:PutLifecycleConfiguration` | `PUT` **and** `DELETE /v1/buckets/{bucket}/lifecycle` |
| `storage:GetEncryptionConfiguration` | `GET /v1/buckets/{bucket}/encryption` |
| `storage:PutEncryptionConfiguration` | `PUT` **and** `DELETE /v1/buckets/{bucket}/encryption` |
| `storage:GetBucketTagging` | `GET /v1/buckets/{bucket}/tagging` |
| `storage:PutBucketTagging` | `PUT` **and** `DELETE /v1/buckets/{bucket}/tagging` |
| `storage:GetBucketObjectLockConfiguration` | `GET /v1/buckets/{bucket}/object-lock` |
| `storage:PutBucketObjectLockConfiguration` | `PUT` **and** `DELETE /v1/buckets/{bucket}/object-lock` |
| `storage:GetBucketLocation` | Apenas protocolo S3 |
| `storage:BypassGovernanceRetention` | substituindo uma retenção de `governance` |

<a id="four-things-the-names-do-not-tell-you" />

### Quatro coisas que os nomes não dizem

**Listagem de objetos precisa `storage:ListBucket`, não um `ListObjects` ação.** A mesma ação abrange a listagem de versões de objetos e a listagem de uploads de várias partes.Esta é a nomenclatura do S3: a ação é nomeada para a coisa que você está listando *dentro*, não para o que vem de volta.

**Listar seus buckets é `storage:ListAllMyBuckets`.** Ele é verificado contra a conta, então não pode ser escopo para buckets particulares — conceder isso permite que um chamador veja que cada bucket existe, e nada mais.

**Remover um sub-recurso de bucket leva a ação `Put`, não uma ação de exclusão.**`DELETE /v1/buckets/{bucket}/cors` requer `storage:PutBucketCORS`; o mesmo vale para ciclo de vida, criptografia, marcação e bloqueio de objetos. Limpar uma configuração é escrevê-la para vazia.

**`DELETE` em uma chave de objeto tem duas respostas.** Apagar o objeto precisa de `storage:DeleteObject`, mas `DELETE /v1/buckets/{bucket}/objects/{key}?tagging` — que remove as tags do objeto e deixa o objeto — precisa de `storage:PutObject`. Remover tags é uma mutação do objeto, não uma exclusão dele. Uma credencial concedida `storage:DeleteObject` sozinha encontrará o formulário de marcação recusado.

<a id="two-layers-on-the-object-side" />

## Duas camadas no lado do objeto

Cada solicitação de objeto é decidida pelo IAM **e** pela política de bucket, nesta ordem:

<Steps>
  <Step title="Chamadas de anônimos">
    A política do bucket decide sozinha. Sem política, não há acesso.
  </Step>

  <Step title="Chamadas de clientes autenticados">
    Um `deny` explícito em **qualquer** camada recusa a solicitação de forma direta. Caso contrário, um `allow` explícito de **qualquer** camada é suficiente para prosseguir. Sem nenhuma das duas, a solicitação é recusada — uma negação implícita.
  </Step>
</Steps>

A política de bucket é a camada que alcança os principais fora da sua conta, incluindo os anônimos. O IAM não pode conceder ao principal de outra pessoa; a política de bucket pode.

Os CRNs de principal de máquina incluem o identificador de conta e o UUID de identidade imutável: `crn:iam::<account-handle>:role/<role-uuid>` ou `crn:iam::<account-handle>:service-account/<service-account-uuid>`. Use a identidade principal imutável, não o CRN de recurso da função que contém seu nome. Os usuários usam CRNs de usuário qualificados pela organização do Workspace. Os grupos não são solicitações de diretores.

O acesso de bucket entre contas ou entre organizações também requer a própria política de conta do principal para permitir a ação. Uma política de bucket não é uma maneira de assumir uma função em outra organização. Negações explícitas permanecem efetivas.

```json theme={null}
{
  "effect": "allow",
  "principals": ["crn:iam::reporting:role/550e8400-e29b-41d4-a716-446655440000"],
  "actions": ["storage:GetObject"],
  "resources": ["*"]
}
```

<Warning>
  **Uma política de bucket que permite anônimos `storage:GetObject` publica esses objetos na internet.** Não há nenhuma segunda opção por trás dela — a política é a opção.
</Warning>

Ambas as camadas param de se aplicar no momento em que a organização do proprietário do bucket é suspensa, incluindo os concessor de contas cruzadas e leitores anônimos.

<a id="resources" />

## Recursos

Os CRNs de armazenamento são baseados em nome e contêm a região e a conta:

```
crn:storage:sa-saopaulo-1:my-account:volume/app-data-01
crn:storage:sa-saopaulo-1:my-account:volume/data/snapshot/pre-upgrade
crn:storage:sa-saopaulo-1:my-account:snapshot-policy/nightly
crn:storage:sa-saopaulo-1:my-account:bucket/reports
crn:storage:sa-saopaulo-1:my-account:bucket/reports/2026/q1.csv
```

O CRN de um objeto é o do bucket com a chave anexada, então uma política pode ter escopo para um prefixo — `bucket/reports/2026/*` — da mesma forma que tem escopo para uma convenção de nomeação em volumes: `crn:storage:*:my-account:volume/prod-*`.

<a id="conditions" />

## Condições

Volumes, snapshots e políticas tomam um mapa de `tags`, e ambas as chaves de contexto de tag se aplicam:

* `basalt:RequestTag/<key>` — o que um chamador pode rotular um recurso **como**, que é o que torna uma criação autorizada antes que o recurso exista.
* `basalt:ResourceTag/<key>` — quais recursos existentes uma ação pode tocar.

Os objetos carregam seus próprios nomes, nomeados para S3 em vez de para nós:

* `s3:RequestObjectTag/<key>` — o que uma escrita está tentando definir.
* `s3:ExistingObjectTag/<key>` — o que já está no objeto.
* `basalt:TagKeys` — o conjunto de chaves de tag que uma requisição carrega.

Apenas volumes de produção, cercados na etiqueta em vez do nome:

```json theme={null}
{
  "version": "2024-01-01",
  "statements": [
    {
      "sid": "ProductionVolumesOnly",
      "effect": "allow",
      "actions": ["storage:CreateVolume", "storage:ExtendVolume"],
      "resources": ["crn:storage:*:my-account:volume/*"],
      "conditions": [
        {
          "operator": "equals",
          "key": "basalt:RequestTag/env",
          "values": ["production"]
        }
      ]
    }
  ]
}
```

Um serviço que lê um prefixo e não escreve nada:

```json theme={null}
{
  "version": "2024-01-01",
  "statements": [
    {
      "sid": "ReportsReadOnly",
      "effect": "allow",
      "actions": ["storage:ListBucket", "storage:GetObject"],
      "resources": [
        "crn:storage:sa-saopaulo-1:my-account:bucket/reports",
        "crn:storage:sa-saopaulo-1:my-account:bucket/reports/2026/*"
      ]
    }
  ]
}
```

<Warning>
  **Ambas as linhas de recursos são necessárias.** `bucket/reports` não cobre os objetos dentro dele — o CRN de um objeto é um caminho mais longo, e uma correspondência de curinga pára no recurso que ele nomeia. `storage:ListBucket` é verificado contra o bucket, `storage:GetObject` contra o objeto.
</Warning>

Veja [writing policies](/pt/iam/policies) para o formato do documento e cada operador de condição.

<a id="what-a-denial-looks-like" />

## Como é uma negação

Uma verificação falhada responde `403`:

```json theme={null}
{
  "error": {
    "code": "ACCESS_DENIED",
    "message": "You don't have permission to perform this action",
    "request_id": "..."
  }
}
```

**Ele não diz qual ação estava faltando**, deliberadamente. Procure a chamada que você fez nas tabelas acima, e a ação que ela precisa é a que você adiciona.

<Note>
  As solicitações no endpoint do protocolo S3 respondem no próprio formato de erro do S3, em vez deste — consulte [os códigos de erro do S3](/pt/storage/troubleshooting). A decisão é a mesma, só o envelope é diferente.
</Note>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.