Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Implémentation des autorisations Amazon Verified dans Rust avec le AWS SDK
Cette rubrique fournit un exemple pratique de mise en œuvre des autorisations Amazon Verified Permissions dans Rust avec le AWS SDK. Cet exemple montre comment développer un modèle d'autorisation permettant de tester si un utilisateur est en mesure de voir une photo. L'exemple de code utilise la [aws-sdk-verifiedpermissions](https://docs.rs/aws-sdk-verifiedpermissions/latest/aws_sdk_verifiedpermissions/)caisse du [AWS SDK pour Rust](https://github.com/awslabs/aws-sdk-rust), qui propose un ensemble robuste d'outils avec lesquels interagir Services AWS.
## Conditions préalables
Avant de commencer, assurez-vous que la [AWS CLI](https://aws.amazon.com/cli/) est configurée sur votre système et que vous connaissez Rust.
+ Pour obtenir des instructions sur l'installation de la CLI AWS CLI, consultez le [guide d'installation de la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html).
+ Pour obtenir des instructions sur la configuration du AWS CLI, consultez [les sections Configuration des paramètres AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html) et [Paramètres des fichiers de configuration et d'identification dans le AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-profiles.html).
+ Pour plus d'informations sur Rust, consultez [rust-lang.org](https://www.rust-lang.org/) et le Guide du développeur du [AWS SDK pour](https://docs.aws.amazon.com//sdk-for-rust/latest/dg/welcome.html) Rust.
Une fois votre environnement préparé, voyons comment implémenter les autorisations vérifiées dans Rust.
## Testez l'exemple de code
L'exemple de code effectue les opérations suivantes :
+ Configure le client SDK pour communiquer avec AWS
+ Crée un [magasin de politiques](policy-stores.md)
+ Définit la structure du magasin de politiques en ajoutant un [schéma](schema.md)
+ Ajoute une [politique](policies.md) pour vérifier les demandes d'autorisation
+ Envoie une [demande d'autorisation](authorization.md) de test pour vérifier que tout est correctement configuré
**Pour tester l'exemple de code**
1. Créez un projet Rust.
1. Remplacez tout code existant `main.rs` par le code suivant :
```
use std::time::Duration;
use std::thread::sleep;
use aws_config::BehaviorVersion;
use aws_sdk_verifiedpermissions::Client;
use aws_sdk_verifiedpermissions::{
operation::{
create_policy::CreatePolicyOutput,
create_policy_store::CreatePolicyStoreOutput,
is_authorized::IsAuthorizedOutput,
put_schema::PutSchemaOutput,
},
types::{
ActionIdentifier, EntityIdentifier, PolicyDefinition, SchemaDefinition, StaticPolicyDefinition, ValidationSettings
},
};
//Function that creates a policy store in the client that's passed
async fn create_policy_store(client: &Client, valid_settings: &ValidationSettings)-> CreatePolicyStoreOutput {
let policy_store = client.create_policy_store().validation_settings(valid_settings.clone()).send().await;
return policy_store.unwrap();
}
//Function that adds a schema to the policy store in the client
async fn put_schema(client: &Client, ps_id: &str, schema: &str) -> PutSchemaOutput {
let schema = client.put_schema().definition(SchemaDefinition::CedarJson(schema.to_string())).policy_store_id(ps_id.to_string()).send().await;
return schema.unwrap();
}
//Function that creates a policy in the policy store in the client
async fn create_policy(client: &Client, ps_id: &str, policy_definition:&PolicyDefinition) -> CreatePolicyOutput {
let create_policy = client.create_policy().definition(policy_definition.clone()).policy_store_id(ps_id).send().await;
return create_policy.unwrap();
}
//Function that tests the authorization request to the policy store in the client
async fn authorize(client: &Client, ps_id: &str, principal: &EntityIdentifier, action: &ActionIdentifier, resource: &EntityIdentifier) -> IsAuthorizedOutput {
let is_auth = client.is_authorized().principal(principal.to_owned()).action(action.to_owned()).resource(resource.to_owned()).policy_store_id(ps_id).send().await;
return is_auth.unwrap();
}
#[::tokio::main]
async fn main() -> Result<(), aws_sdk_verifiedpermissions::Error> {
//Set up SDK client
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
let client = aws_sdk_verifiedpermissions::Client::new(&config);
//Create a policy store
let valid_settings = ValidationSettings::builder()
.mode({aws_sdk_verifiedpermissions::types::ValidationMode::Strict
})
.build()
.unwrap();
let policy_store = create_policy_store(&client, &valid_settings).await;
println!(
"Created Policy store with ID: {:?}",
policy_store.policy_store_id
);
//Add schema to policy store
let schema= r#"{
"PhotoFlash": {
"actions": {
"ViewPhoto": {
"appliesTo": {
"context": {
"type": "Record",
"attributes": {}
},
"principalTypes": [
"User"
],
"resourceTypes": [
"Photo"
]
},
"memberOf": []
}
},
"entityTypes": {
"Photo": {
"memberOfTypes": [],
"shape": {
"type": "Record",
"attributes": {
"IsPrivate": {
"type": "Boolean"
}
}
}
},
"User": {
"memberOfTypes": [],
"shape": {
"attributes": {},
"type": "Record"
}
}
}
}
}"#;
let put_schema = put_schema(&client, &policy_store.policy_store_id, schema).await;
println!(
"Created Schema with Namespace: {:?}",
put_schema.namespaces
);
//Create policy
let policy_text = r#"
permit (
principal in PhotoFlash::User::"alice",
action == PhotoFlash::Action::"ViewPhoto",
resource == PhotoFlash::Photo::"VacationPhoto94.jpg"
);
"#;
let policy_definition = PolicyDefinition::Static(StaticPolicyDefinition::builder().statement(policy_text).build().unwrap());
let policy = create_policy(&client, &policy_store.policy_store_id, &policy_definition).await;
println!(
"Created Policy with ID: {:?}",
policy.policy_id
);
//Break to make sure the resources are created before testing authorization
sleep(Duration::new(2, 0));
//Test authorization
let principal= EntityIdentifier::builder().entity_id("alice").entity_type("PhotoFlash::User").build().unwrap();
let action = ActionIdentifier::builder().action_type("PhotoFlash::Action").action_id("ViewPhoto").build().unwrap();
let resource = EntityIdentifier::builder().entity_id("VacationPhoto94.jpg").entity_type("PhotoFlash::Photo").build().unwrap();
let auth = authorize(&client, &policy_store.policy_store_id, &principal, &action, &resource).await;
println!(
"Decision: {:?}",
auth.decision
);
println!(
"Policy ID: {:?}",
auth.determining_policies
);
Ok(())
}
```
1. Exécutez le code en entrant `cargo run` dans le terminal.
Si le code s'exécute correctement, le terminal s'affichera, `Decision: Allow` suivi de l'ID de politique de la politique déterminante. Cela signifie que vous avez créé avec succès un magasin de politiques et que vous l'avez testé à l'aide du AWS SDK pour Rust.
## nettoyer des ressources ;
Une fois que vous avez fini d'explorer votre magasin de politiques, supprimez-le.
**Pour supprimer un entrepôt de politiques**
Vous pouvez supprimer un magasin de politiques en utilisant cette `delete-policy-store` opération, en le `PSEXAMPLEabcdefg111111` remplaçant par l'ID du magasin de politiques que vous souhaitez supprimer.
```
$ aws verifiedpermissions delete-policy-store \
--policy-store-id PSEXAMPLEabcdefg111111
```
Cette commande ne produit aucune sortie si elle réussit.