Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menerapkan Izin Terverifikasi Amazon di Rust dengan SDK AWS
<a name="code-samples-rust"></a>

Topik ini memberikan contoh praktis penerapan Izin Terverifikasi Amazon di Rust dengan AWS SDK. Contoh ini menunjukkan bagaimana mengembangkan model otorisasi yang dapat menguji apakah pengguna dapat melihat foto. Kode sampel menggunakan [aws-sdk-verifiedpermissions](https://docs.rs/aws-sdk-verifiedpermissions/latest/aws_sdk_verifiedpermissions/)peti dari [AWS SDK for Rust](https://github.com/awslabs/aws-sdk-rust), yang menawarkan seperangkat alat yang kuat untuk berinteraksi. Layanan AWS

## Prasyarat
<a name="rust-prereqs"></a>

 Sebelum memulai, pastikan bahwa Anda memiliki [AWS CLI](https://aws.amazon.com/cli/) yang dikonfigurasi pada sistem Anda dan bahwa Anda terbiasa dengan Rust.
+ Untuk petunjuk tentang menginstal AWS CLI, lihat panduan [instalasi AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html).
+ Untuk petunjuk tentang mengonfigurasi AWS CLI, lihat [Mengonfigurasi pengaturan untuk pengaturan AWS CLI dan Konfigurasi](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html) [dan file kredensi](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-profiles.html) di. AWS CLI
+ Untuk informasi selengkapnya tentang Rust, lihat [rust-lang.org](https://www.rust-lang.org/) dan [AWS SDK for](https://docs.aws.amazon.com//sdk-for-rust/latest/dg/welcome.html) Rust Developer Guide.

Dengan lingkungan Anda siap, mari jelajahi cara menerapkan Izin Terverifikasi di Rust.

## Uji kode sampel
<a name="rust-code"></a>

Kode sampel melakukan hal berikut:
+ Menyiapkan klien SDK untuk berkomunikasi AWS
+ Membuat [toko kebijakan](policy-stores.md)
+ [Mendefinisikan struktur toko kebijakan dengan menambahkan skema](schema.md)
+ Menambahkan [kebijakan](policies.md) untuk memeriksa permintaan otorisasi
+ Mengirim [permintaan otorisasi](authorization.md) pengujian untuk memverifikasi semuanya sudah diatur dengan benar

**Untuk menguji kode sampel**

1. Buat proyek Rust.

1. Ganti kode yang ada `main.rs` dengan kode berikut:

   ```
   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. Jalankan kode dengan memasukkan `cargo run` di terminal.

Jika kode berjalan dengan benar, terminal akan ditampilkan `Decision: Allow` diikuti dengan ID kebijakan dari kebijakan penentu. Ini berarti Anda telah berhasil membuat toko kebijakan dan mengujinya menggunakan AWS SDK for Rust.

## Pembersihan sumber daya
<a name="rust-clean-up"></a>

Setelah Anda selesai menjelajahi toko kebijakan Anda, hapus.

**Untuk menghapus toko kebijakan**  
Anda dapat menghapus penyimpanan kebijakan dengan menggunakan `delete-policy-store` operasi, menggantinya `PSEXAMPLEabcdefg111111` dengan ID penyimpanan kebijakan yang ingin Anda hapus.

```
$ aws verifiedpermissions delete-policy-store \
    --policy-store-id PSEXAMPLEabcdefg111111
```

Jika berhasil, perintah ini tidak menghasilkan output.