Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Implementación de permisos verificados de Amazon en Rust con el AWS SDK
En este tema se proporciona un ejemplo práctico de la implementación de permisos verificados de Amazon en Rust con el AWS SDK. En este ejemplo se muestra cómo desarrollar un modelo de autorización que pueda comprobar si un usuario puede ver una foto. El código de ejemplo utiliza la [aws-sdk-verifiedpermissions](https://docs.rs/aws-sdk-verifiedpermissions/latest/aws_sdk_verifiedpermissions/)caja del [AWS SDK para Rust](https://github.com/awslabs/aws-sdk-rust), que ofrece un conjunto sólido de herramientas con Servicios de AWS las que interactuar.
## Requisitos previos
Antes de comenzar, asegúrese de tener la [AWS CLI](https://aws.amazon.com/cli/) configurada en su sistema y de estar familiarizado con Rust.
+ Para obtener instrucciones sobre la instalación del AWS CLI, consulte la [guía de instalación de AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html).
+ Para obtener instrucciones sobre cómo configurar el AWS CLI, consulte [Configuración de los ajustes AWS CLI y los](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html) ajustes del [archivo de credenciales y configuración en el AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-profiles.html).
+ Para obtener más información sobre Rust, consulta [rust-lang.org](https://www.rust-lang.org/) y la Guía del desarrollador del [AWS SDK para Rust.](https://docs.aws.amazon.com//sdk-for-rust/latest/dg/welcome.html)
Con el entorno preparado, exploremos cómo implementar los permisos verificados en Rust.
## Pruebe el código de muestra
El código de ejemplo hace lo siguiente:
+ Configura el cliente del SDK con el que se comunicará AWS
+ Crea un [almacén de políticas](policy-stores.md)
+ Define la estructura del almacén de políticas mediante la adición de un [esquema](schema.md)
+ Añade una [política](policies.md) para comprobar las solicitudes de autorización
+ Envía una [solicitud de autorización](authorization.md) de prueba para comprobar que todo está configurado correctamente
**Para probar el código de muestra**
1. Crea un proyecto de Rust.
1. Sustituya cualquier código existente `main.rs` por el siguiente código:
```
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. Ejecute el código ingresándolo `cargo run` en la terminal.
Si el código se ejecuta correctamente, aparecerá el terminal `Decision: Allow` seguido del identificador de política de la política determinante. Esto significa que has creado correctamente un almacén de políticas y lo has probado con el AWS SDK de Rust.
## Eliminar recursos
Cuando hayas terminado de explorar tu almacén de políticas, elimínalo.
**Para eliminar un almacén de políticas**
Puede eliminar un almacén de políticas mediante la `delete-policy-store` operación y `PSEXAMPLEabcdefg111111` sustituirlo por el ID del almacén de políticas que desee eliminar.
```
$ aws verifiedpermissions delete-policy-store \
--policy-store-id PSEXAMPLEabcdefg111111
```
Si se ejecuta correctamente, este comando no genera ninguna salida.