Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Implementierung von Amazon Verified Permissions in Rust mit dem AWS SDK
<a name="code-samples-rust"></a>

Dieses Thema bietet ein praktisches Beispiel für die Implementierung von Amazon Verified Permissions in Rust mit dem AWS SDK. Dieses Beispiel zeigt, wie ein Autorisierungsmodell entwickelt wird, mit dem getestet werden kann, ob ein Benutzer ein Foto ansehen kann. Der Beispielcode verwendet die [aws-sdk-verifiedpermissions](https://docs.rs/aws-sdk-verifiedpermissions/latest/aws_sdk_verifiedpermissions/)Kiste aus der [AWS SDK für Rust](https://github.com/awslabs/aws-sdk-rust), die eine Reihe robuster Tools für die Interaktion mit AWS-Services bietet.

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

 Stellen Sie vor dem Start sicher, dass Sie die [AWS CLI](https://aws.amazon.com/cli/) auf Ihrem System konfiguriert haben und dass Sie mit Rust vertraut sind.
+ Anweisungen zur Installation von finden Sie in der AWS CLI[AWS CLI-Installationsanleitung](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html).
+ Anweisungen zur Konfiguration von finden Sie unter [Konfiguration der AWS CLI Einstellungen für](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-quickstart.html) und [Einstellungen für Konfiguration AWS CLI und Anmeldeinformationsdatei in der AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-profiles.html).
+ Weitere Informationen zu rust finden Sie auf [rust-lang.org](https://www.rust-lang.org/) und im [AWS SDK for Rust](https://docs.aws.amazon.com//sdk-for-rust/latest/dg/welcome.html) Developer Guide.

Nachdem Ihre Umgebung vorbereitet ist, wollen wir untersuchen, wie verifizierte Berechtigungen in Rust implementiert werden können.

## Testen Sie den Beispielcode
<a name="rust-code"></a>

Der Beispielcode macht Folgendes:
+ Richtet den SDK-Client für die Kommunikation ein AWS
+ Erstellt einen [Richtlinienspeicher](policy-stores.md)
+ Definiert die Struktur des Richtlinienspeichers durch Hinzufügen eines [Schemas](schema.md)
+ Fügt eine [Richtlinie](policies.md) zur Überprüfung von Autorisierungsanfragen hinzu
+ Sendet eine [Testautorisierungsanfrage](authorization.md), um zu überprüfen, ob alles korrekt eingerichtet ist

**So testen Sie den Beispiel-Code**

1. Erstellen Sie ein Rust-Projekt.

1. Ersetzen Sie jeden vorhandenen Code `main.rs` durch den folgenden Code:

   ```
   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. Führen Sie den Code aus, indem Sie `cargo run` ihn in das Terminal eingeben.

Wenn der Code korrekt ausgeführt wird, wird das Terminal angezeigt, `Decision: Allow` gefolgt von der Richtlinien-ID der betreffenden Richtlinie. Das bedeutet, dass Sie erfolgreich einen Richtlinienspeicher erstellt und ihn mit dem AWS SDK für Rust getestet haben.

## Bereinigen von Ressourcen
<a name="rust-clean-up"></a>

Nachdem Sie Ihren Richtlinienspeicher durchsucht haben, löschen Sie ihn.

**So löschen Sie einen Richtlinienspeicher**  
Sie können einen Richtlinienspeicher löschen, indem Sie den `delete-policy-store` Vorgang durch die Richtlinienspeicher-ID `PSEXAMPLEabcdefg111111` ersetzen, die Sie löschen möchten.

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

Wenn er erfolgreich ist, erzeugt dieser Befehl keine Ausgabe.