Differenze tra Amazon Verified Permissions e il linguaggio delle policy Cedar - Autorizzazioni verificate da Amazon
Definizione dello spazio dei nomiSupporto per modelli di policySupporto dello schemaSupporto per tipi di estensioneJSONFormato Cedar per le entitàDefinizione dei gruppi di azioneFormattazione delle entitàLimiti di lunghezza e dimensione

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Differenze tra Amazon Verified Permissions e il linguaggio delle policy Cedar

Amazon Verified Permissions utilizza il motore linguistico Cedar Policy per eseguire le proprie attività di autorizzazione. Tuttavia, ci sono alcune differenze tra l'implementazione nativa di Cedar e l'implementazione di Cedar che si trovano in Verified Permissions. Questo argomento identifica queste differenze.

Definizione dello spazio dei nomi

L'implementazione Verified Permissions di Cedar presenta le seguenti differenze rispetto all'implementazione nativa di Cedar:

  • Verified Permissions supporta solo uno spazio dei nomi in uno schema definito in un policy store.

  • Le autorizzazioni verificate non consentono di creare uno spazio dei nomi che sia una stringa vuota o che includa i seguenti valori:, o. aws amazon cedar

Supporto per modelli di policy

Sia Verified Permissions che Cedar consentono di inserire i segnaposto nell'ambito solo per il termine e. principal resource Tuttavia, le autorizzazioni verificate richiedono anche che nessuna delle due e sia priva di vincoli. principal resource

La seguente politica è valida in Cedar ma viene rifiutata da Verified Permissions perché non è vincolata. principal

permit(principal, action == Action::"view", resource == ?resource);

Entrambi gli esempi seguenti sono validi sia in Cedar che in Verified Permissions perché entrambi hanno dei vincoli. principal resource

permit(principal == User::"alice", action == Action::"view", resource == ?resource);
permit(principal == ?principal, action == Action::"a", resource in ?resource);

Supporto dello schema

Verified Permissions richiede che tutti i nomi delle JSON chiavi dello schema siano stringhe non vuote. Cedar consente stringhe vuote in alcuni casi, ad esempio per proprietà o namespace.

Supporto per tipi di estensione

Verified Permissions supporta i tipi di estensione Cedar nelle politiche, ma attualmente non supporta la loro inclusione nella definizione di uno schema tramite la console Verified Permissions.

I tipi di estensione includono i tipi di dati fixed point (decimal) e IP address (ipaddr).

JSONFormato Cedar per le entità

Al momento, Verified Permissions richiede di passare l'elenco delle entità da prendere in considerazione in una richiesta di autorizzazione utilizzando la struttura definita per the EntitiesDefinition, che è una matrice di elementi. EntityItem Verified Permissions attualmente non supporta il passaggio dell'elenco di entità da considerare in una richiesta di autorizzazione in formato Cedar. JSON Per requisiti specifici di formattazione delle entità da utilizzare nelle autorizzazioni verificate, consulta. Formattazione delle entità

Definizione dei gruppi di azione

I metodi di autorizzazione Cedar richiedono un elenco delle entità da prendere in considerazione quando si valuta una richiesta di autorizzazione rispetto alle politiche.

È possibile definire le azioni e i gruppi di azioni utilizzati dall'applicazione nello schema. Tuttavia, Cedar non include lo schema come parte di una richiesta di valutazione. Invece, Cedar utilizza lo schema solo per convalidare le politiche e i modelli di policy inviati. Poiché Cedar non fa riferimento allo schema durante le richieste di valutazione, anche se nello schema sono stati definiti gruppi di azioni, è necessario includere anche l'elenco di tutti i gruppi di azioni come parte dell'elenco delle entità da passare alle operazioni di autorizzazione. API

Verified Permissions lo fa per te. Tutti i gruppi di azioni definiti nello schema vengono aggiunti automaticamente all'elenco di entità a cui si passa come parametro alle operazioni IsAuthorized orIsAuthorizedWithToken.

Formattazione delle entità

La JSON formattazione delle entità in Verified Permissions differisce da Cedar nei seguenti modi:

  • In Verified Permissions, un JSON oggetto deve avere tutte le sue coppie chiave-valore racchiavette in un oggetto con il nome di. JSON Record

  • Un JSON elenco in Autorizzazioni verificate deve essere racchiuso in una coppia JSON chiave-valore in cui il nome della chiave è Set e il valore è l'elenco originale di Cedar. JSON

  • Per i nomi Boolean di tipo e StringLong, ogni coppia chiave-valore di Cedar viene sostituita da un oggetto in Verified Permissions. JSON Il nome dell'oggetto è il nome della chiave originale. All'interno dell'JSONoggetto, c'è una coppia chiave-valore in cui il nome della chiave è il nome del tipo del valore scalare (StringLong, oBoolean) e il valore è il valore dell'entità Cedar.

  • La formattazione della sintassi delle entità Cedar e delle entità Verified Permissions differisce nei seguenti modi:

    Formato Cedar Formato di autorizzazioni verificate
    uid Identifier
    type EntityType
    id EntityId
    attrs Attributes
    parents Parents
Esempio - Elenchi

Gli esempi seguenti mostrano come un elenco di entità viene espresso rispettivamente in Cedar e Verified Permissions.

Cedar
[
  {
    "number": 1
  },
  {
    "sentence": "Here is an example sentence"
  },
  {
    "Question": false
  }
]
Verified Permissions
{
  "Set": [
    {
      "Record": {
        "number": {
          "Long": 1
        }
      }
    },
    {
      "Record": {
        "sentence": {
          "String": "Here is an example sentence"
        }
      }
    },
    {
      "Record": {
        "question": {
          "Boolean": false
        }
      }
    }
  ]
}
Esempio - Valutazione delle politiche

Gli esempi seguenti mostrano come le entità sono formattate per la valutazione di una politica in una richiesta di autorizzazione in Cedar e Verified Permissions, rispettivamente.

Cedar
[
    {
        "uid": {
            "type": "PhotoApp::User",
            "id": "alice"
        },
        "attrs": {
            "age": 25,
            "name": "alice",
            "userId": "123456789012"
        },
        "parents": [
            {
                "type": "PhotoApp::UserGroup",
                "id": "alice_friends"
            },
            {
                "type": "PhotoApp::UserGroup",
                "id": "AVTeam"
            }
        ]
    },
    {
        "uid": {
            "type": "PhotoApp::Photo",
            "id": "vacationPhoto.jpg"
        },
        "attrs": {
            "private": false,
            "account": {
                "__entity": {
                    "type": "PhotoApp::Account",
                    "id": "ahmad"
                }
            }
        },
        "parents": []
    },
    {
        "uid": {
            "type": "PhotoApp::UserGroup",
            "id": "alice_friends"
        },
        "attrs": {},
        "parents": []
    },
    {
        "uid": {
            "type": "PhotoApp::UserGroup",
            "id": "AVTeam"
        },
        "attrs": {},
        "parents": []
    }
]
Verified Permissions
[
    {
        "Identifier": {
            "EntityType": "PhotoApp::User",
            "EntityId": "alice"
        },
        "Attributes": {
            "age": {
                "Long": 25
            },
            "name": {
                "String": "alice"
            },
            "userId": {
                "String": "123456789012"
            }
        },
        "Parents": [
            {
                "EntityType": "PhotoApp::UserGroup",
                "EntityId": "alice_friends"
            },
            {
                "EntityType": "PhotoApp::UserGroup",
                "EntityId": "AVTeam"
            }
        ]
    },
    {
        "Identifier": {
            "EntityType": "PhotoApp::Photo",
            "EntityId": "vacationPhoto.jpg"
        },
        "Attributes": {
            "private": {
                "Boolean": false
            },
            "account": {
                "EntityIdentifier": {
                    "EntityType": "PhotoApp::Account",
                    "EntityId": "ahmad"
                }
            }
        },
        "Parents": []
    },
    {
        "Identifier": {
            "EntityType": "PhotoApp::UserGroup",
            "EntityId": "alice_friends"
        },
        "Parents": []
    },
    {
        "Identifier": {
            "EntityType": "PhotoApp::UserGroup",
            "EntityId": "AVTeam"
        },
        "Parents": []
    }
]

Limiti di lunghezza e dimensione

Verified Permissions supporta l'archiviazione sotto forma di archivi di policy per archiviare schemi, policy e modelli di policy. Tale archiviazione fa sì che le autorizzazioni verificate impongano alcuni limiti di lunghezza e dimensione che non sono rilevanti per Cedar.

Oggetto Limite di autorizzazioni verificate (in byte) Limite Cedar
Dimensione della polizza¹ 10.000 Nessuno
Descrizione della politica in linea 150 Non applicabile a Cedar
Dimensioni del modello di policy 10.000 Nessuno
Dimensioni dello schema 100.000 Nessuno
Tipo di entità 200 Nessuno
ID Policy 64 Nessuno
ID del modello di policy 64 Nessuno
ID entità 200 Nessuno
ID dell'archivio delle politiche 64 Non applicabile a Cedar

¹ Esiste un limite di policy per policy store in Verified Permissions in base alla dimensione combinata dei principali, delle azioni e delle risorse dei criteri creati nell'archivio delle politiche. La dimensione totale di tutte le policy relative a una singola risorsa non può superare i 200.000 byte. Per le policy collegate al modello, la dimensione del modello di policy viene conteggiata una sola volta, più la dimensione di ogni set di parametri utilizzato per creare un'istanza di ogni policy collegata al modello.