As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Implementando permissões verificadas da Amazon no Rust com o SDK AWS
Este tópico fornece um exemplo prático da implementação de permissões verificadas da Amazon no Rust com o AWS SDK. Este exemplo mostra como desenvolver um modelo de autorização que pode testar se um usuário consegue ver uma foto. O código de amostra usa a [aws-sdk-verifiedpermissions](https://docs.rs/aws-sdk-verifiedpermissions/latest/aws_sdk_verifiedpermissions/)caixa do [AWS SDK para Rust](https://github.com/awslabs/aws-sdk-rust), que oferece um conjunto robusto de ferramentas para interagir com. Serviços da AWS
## Pré-requisitos
Antes de começar, certifique-se de ter a [AWS CLI](https://aws.amazon.com/cli/) configurada em seu sistema e de estar familiarizado com o Rust.
+ Para obter instruções sobre como instalar o AWS CLI, consulte o guia de [instalação da AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html).
+ Para obter instruções sobre como configurar o AWS CLI, consulte [Definindo as configurações do AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html) e [Configuração e do arquivo de credenciais no](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-profiles.html). AWS CLI
+ Para obter mais informações sobre Rust, consulte [rust-lang.org](https://www.rust-lang.org/) e o [AWS SDK](https://docs.aws.amazon.com//sdk-for-rust/latest/dg/welcome.html) for Rust Developer Guide.
Com seu ambiente preparado, vamos explorar como implementar permissões verificadas no Rust.
## Teste o código de amostra
O código de amostra faz o seguinte:
+ Configura o cliente SDK para se comunicar com AWS
+ Cria um [repositório de políticas](policy-stores.md)
+ Define a estrutura do repositório de políticas adicionando um [esquema](schema.md)
+ Adiciona uma [política](policies.md) para verificar as solicitações de autorização
+ Envia uma [solicitação de autorização](authorization.md) de teste para verificar se tudo está configurado corretamente
**Para testar o código de exemplo**
1. Crie um projeto Rust.
1. Substitua qualquer código existente pelo seguinte código: `main.rs`
```
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. Execute o código inserindo `cargo run` no terminal.
Se o código for executado corretamente, o terminal será exibido `Decision: Allow` seguido pelo ID da política determinante. Isso significa que você criou com sucesso um repositório de políticas e o testou usando o AWS SDK para Rust.
## Limpar os recursos
Depois de terminar de explorar seu repositório de políticas, exclua-o.
**Para excluir um armazenamento de políticas**
Você pode excluir um repositório de políticas usando a `delete-policy-store` operação, `PSEXAMPLEabcdefg111111` substituindo-o pelo ID do repositório de políticas que você deseja excluir.
```
$ aws verifiedpermissions delete-policy-store \
--policy-store-id PSEXAMPLEabcdefg111111
```
Se for bem-sucedido, esse comando não gerará nenhum resultado.