From 6133c73af8dc35a818b9a59627bf968ee991dce5 Mon Sep 17 00:00:00 2001
From: Partik <partikbumrah13508@gmail.com>
Date: Wed, 10 Jul 2024 17:37:27 +0530
Subject: [PATCH] Completed AWS package

Signed-off-by: Partik <partikbumrah13508@gmail.com>
---
 rustcloud/src/aws/aws_apis/compute/aws_ec2.rs | 282 ++++++++----------
 rustcloud/src/aws/aws_apis/compute/aws_ecs.rs |  99 ++++--
 rustcloud/src/aws/aws_apis/compute/aws_eks.rs | 193 ++++++++----
 .../src/aws/aws_apis/compute/aws_paas.rs      |   0
 .../src/aws/aws_apis/database/aws_dynamodb.rs |  74 +++--
 .../aws/aws_apis/management/aws_monitoring.rs |  63 +++-
 rustcloud/src/aws/aws_apis/network/aws_dns.rs |  57 +++-
 .../aws/aws_apis/network/aws_loadbalancer.rs  |  71 ++++-
 .../src/aws/aws_apis/security/aws_iam.rs      |  77 +++--
 .../aws_apis/security/aws_keymanagement.rs    |  70 ++++-
 .../aws_apis/storage/aws_archival_storage.rs  |  70 ++++-
 .../aws/aws_apis/storage/aws_block_storage.rs |  52 +++-
 .../aws_apis/storage/aws_storage_bucket.rs    |  64 +++-
 rustcloud/src/main.rs                         |   1 -
 rustcloud/src/tests/archival_operations.rs    |  36 +--
 rustcloud/src/tests/block_operations.rs       |  27 +-
 rustcloud/src/tests/bucket_operations.rs      |  78 +++++
 rustcloud/src/tests/dns_operations.rs         |  74 ++---
 rustcloud/src/tests/dynamodb_operations.rs    |  31 +-
 rustcloud/src/tests/ec2_operations.rs         |  58 ++--
 rustcloud/src/tests/ecs_operations.rs         |  45 ++-
 rustcloud/src/tests/eks_operations.rs         |  55 ++--
 rustcloud/src/tests/iam_operations.rs         |  29 +-
 rustcloud/src/tests/kms_operations.rs         |  36 ++-
 .../src/tests/loadbalancer_operations.rs      |  28 +-
 rustcloud/src/tests/mod.rs                    |   3 +-
 rustcloud/src/tests/monitoring_operations.rs  |  20 +-
 27 files changed, 1089 insertions(+), 604 deletions(-)
 delete mode 100644 rustcloud/src/aws/aws_apis/compute/aws_paas.rs
 create mode 100644 rustcloud/src/tests/bucket_operations.rs

diff --git a/rustcloud/src/aws/aws_apis/compute/aws_ec2.rs b/rustcloud/src/aws/aws_apis/compute/aws_ec2.rs
index f2ff6a1..8d4c8d3 100644
--- a/rustcloud/src/aws/aws_apis/compute/aws_ec2.rs
+++ b/rustcloud/src/aws/aws_apis/compute/aws_ec2.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::result_large_err)]
 
 use aws_config::meta::region::RegionProviderChain;
-use aws_sdk_ec2::{types::Tag, Client, Error};
+use aws_sdk_ec2::{operation::run_instances::RunInstancesError, types::Tag, Client, Error};
+
 // use clap::Parser;
 
 pub async fn create_instance(client: &Client, ami_id: &str) -> Result<(), Error> {
@@ -12,185 +13,162 @@ pub async fn create_instance(client: &Client, ami_id: &str) -> Result<(), Error>
         .min_count(1)
         .max_count(1)
         .send()
-        .await?;
-
-    if run_instances.instances().is_empty() {
-        panic!("No instances created.");
-    }
-
-    println!("Created instance.");
-
-    let instance_id = run_instances.instances()[0].instance_id().unwrap();
-    client
-        .create_tags()
-        .resources(instance_id)
-        .tags(
-            Tag::builder()
-                .key("Name")
-                .value("From SDK Examples")
-                .build(),
-        )
-        .send()
-        .await?;
-
-    println!("Created {instance_id} and applied tags.",);
-
-    Ok(())
+        .await;
+
+    match run_instances {
+        Ok(run_instances) => {
+            if run_instances.instances().is_empty() {
+            panic!("No instances created.");
+            let instance_id = run_instances.instances()[0].instance_id().unwrap();
+            client
+                .create_tags()
+                .resources(instance_id)
+                .tags(
+                    Tag::builder()
+                        .key("Name")
+                        .value("From SDK Examples")
+                        .build(),
+                )
+                .send()
+                .await.unwrap();
+        
+            println!("Created {instance_id} and applied tags.",);
+        
+        }
+            Ok(())
+        }
+        Err(err) => {
+            println!("Error: {:?}", err);
+            Err(err.into())
+        }
+   
 }
 
+}
 pub async fn show_state(client: &Client, ids: Option<Vec<String>>) -> Result<(), Error> {
     let resp = client
         .describe_instances()
         .set_instance_ids(ids)
         .send()
-        .await?;
-
-    for reservation in resp.reservations() {
-        for instance in reservation.instances() {
-            println!("Instance ID: {}", instance.instance_id().unwrap());
-            println!(
-                "State:       {:?}",
-                instance.state().unwrap().name().unwrap()
-            );
-            println!();
+        .await;
+
+    match resp {
+        Ok(result) => {
+            for reservation in result.reservations() {
+                for instance in reservation.instances() {
+                    println!("Instance ID: {}", instance.instance_id().unwrap());
+                    println!(
+                        "State:       {:?}",
+                        instance.state().unwrap().name().unwrap()
+                    );
+                    println!();
+                }
+            }
+            Ok(())
+        },
+        Err(e) => {
+            println!("Error: {:?}", e);
+            Err(e.into()) 
         }
     }
-
-    Ok(())
 }
 
-pub async fn show_all_events(client: &Client) -> Result<(), Error> {
-    let resp = client.describe_regions().send().await.unwrap();
-
-    for region in resp.regions.unwrap_or_default() {
-        let reg: &'static str = Box::leak(Box::from(region.region_name().unwrap()));
-        let region_provider = RegionProviderChain::default_provider().or_else(reg);
-        let config = aws_config::from_env().region(region_provider).load().await;
-        let new_client = Client::new(&config);
 
-        let resp = new_client.describe_instance_status().send().await;
-
-        println!("Instances in region {}:", reg);
-        println!();
-
-        for status in resp.unwrap().instance_statuses() {
-            println!(
-                "  Events scheduled for instance ID: {}",
-                status.instance_id().unwrap_or_default()
-            );
-            for event in status.events() {
-                println!("    Event ID:     {}", event.instance_event_id().unwrap());
-                println!("    Description:  {}", event.description().unwrap());
-                println!("    Event code:   {}", event.code().unwrap().as_ref());
+pub async fn show_all_events(client: &Client) -> Result<(), Error> {
+    let resp = client.describe_regions().send().await;
+    match resp {
+        Ok(result) => {
+            for region in result.regions.unwrap_or_default() {
+                let reg: &'static str = Box::leak(Box::from(region.region_name().unwrap()));
+                let region_provider = RegionProviderChain::default_provider().or_else(reg);
+                let config = aws_config::from_env().region(region_provider).load().await;
+                let new_client = Client::new(&config);
+        
+                let resp = new_client.describe_instance_status().send().await;
+        
+                println!("Instances in region {}:", reg);
                 println!();
+        
+                for status in resp.unwrap().instance_statuses() {
+                    println!(
+                        "  Events scheduled for instance ID: {}",
+                        status.instance_id().unwrap_or_default()
+                    );
+                    for event in status.events() {
+                        println!("    Event ID:     {}", event.instance_event_id().unwrap());
+                        println!("    Description:  {}", event.description().unwrap());
+                        println!("    Event code:   {}", event.code().unwrap().as_ref());
+                        println!();
+                    }
+                }
             }
+        
+            Ok(())
+        }
+        Err(err) => {
+            println!("Error: {:?}", err);
+            Err(err.into())
         }
     }
 
-    Ok(())
+    // let result = resp?;
+
+    
 }
 
 pub async fn enable_monitoring(client: &Client, id: &str) -> Result<(), Error> {
-    client.monitor_instances().instance_ids(id).send().await?;
-
-    println!("Enabled monitoring");
+    let res =  client.monitor_instances().instance_ids(id).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Enabled monitoring: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Monitoring failed: {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
 }
 
 pub async fn reboot_instance(client: &Client, id: &str) -> Result<(), Error> {
-    client.reboot_instances().instance_ids(id).send().await?;
-
-    println!("Rebooted instance.");
-    Ok(())
+    let res = client.reboot_instances().instance_ids(id).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Enabled monitoring: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error rebooting instance: {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn start_instance(client: &Client, id: &str) -> Result<(), Error> {
-    client.start_instances().instance_ids(id).send().await?;
-
-    println!("Started instance.");
-
-    Ok(())
+    let res = client.start_instances().instance_ids(id).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Enabled monitoring: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error rebooting instance: {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn stop_instance(client: &Client, id: &str) -> Result<(), Error> {
-    client.stop_instances().instance_ids(id).send().await?;
-
-    println!("Stopped instance.");
-
-    Ok(())
+    let res = client.stop_instances().instance_ids(id).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Enabled monitoring: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error rebooting instance: {:?}", e);
+            Err(e.into())
+        }
+    }
 }
-// fn mock_client() -> Client {
-//     // Create a mock client for testing purposes
-//     Client::new(&aws_config::load_from_env().await)
-// }
-
-// fn mock_run_instances_output() -> RunInstancesOutput {
-//     // Create a mock RunInstancesOutput for testing purposes
-//     RunInstancesOutput::builder()
-//         .instances(
-//             std::iter::once(aws_sdk_ec2::output::Instance::builder()
-//                 .instance_id("mock-instance-id")
-//                 .build())
-//             .collect(),
-//         )
-//         .build()
-// }
-
-// fn mock_create_tags_output() -> CreateTagsOutput {
-//     // Create a mock CreateTagsOutput for testing purposes
-//     CreateTagsOutput::builder().build()
-// }
-
-
-// #[cfg(test)]
-
-
-// #[test]
-// fn test_create_instance_success() {
-//     let client = mock_client();
-//     let ami_id = "mock-ami-id";
-
-//     // Mock the run_instances method
-//     let mut run_instances_mock = client.run_instances().image_id(ami_id);
-//     run_instances_mock = run_instances_mock
-//         .instance_type(InstanceType::T1Micro)
-//         .min_count(1)
-//         .max_count(1)
-//         .send()
-//         .mocked(|_, _| Ok(mock_run_instances_output()));
-
-//     // Mock the create_tags method
-//     let mut create_tags_mock = client.create_tags();
-//     create_tags_mock = create_tags_mock
-//         .resources("mock-instance-id")
-//         .tags(
-//             Tag::builder()
-//                 .key("Name")
-//                 .value("From SDK Examples")
-//                 .build(),
-//         )
-//         .send()
-//         .mocked(|_, _| Ok(mock_create_tags_output()));
-
-//     let result = create_instance(&client, ami_id).unwrap();
-//     assert!(result.is_ok());
-// }
-
-// #[test]
-// #[should_panic(expected = "No instances created.")]
-// fn test_create_instance_no_instances_created() {
-//     let client = mock_client();
-//     let ami_id = "mock-ami-id";
-
-//     // Mock the run_instances method to return an empty list of instances
-//     let mut run_instances_mock = client.run_instances().image_id(ami_id);
-//     run_instances_mock = run_instances_mock
-//         .instance_type(InstanceType::T1Micro)
-//         .min_count(1)
-//         .max_count(1)
-//         .send()
-//         .mocked(|_, _| Ok(RunInstancesOutput::builder().build()));
-
-//     let _result = create_instance(&client, ami_id).unwrap();
-// }
\ No newline at end of file
diff --git a/rustcloud/src/aws/aws_apis/compute/aws_ecs.rs b/rustcloud/src/aws/aws_apis/compute/aws_ecs.rs
index 4f95192..209d458 100644
--- a/rustcloud/src/aws/aws_apis/compute/aws_ecs.rs
+++ b/rustcloud/src/aws/aws_apis/compute/aws_ecs.rs
@@ -4,11 +4,19 @@ use aws_sdk_ecs::types::{ClusterConfiguration, ClusterField, ClusterSetting};
 use aws_sdk_ecs::{types::Tag, Client, Error};
 
 
-pub async fn create_cluster(client: &Client, name: &String, tags: Option<Vec<Tag>>, settings : ClusterSetting,configuration : ClusterConfiguration, capacity_providers:  Option<Vec<String>>) -> Result<(), Error> {
-    let cluster = client.create_cluster().cluster_name(name).set_tags(tags).settings(settings).configuration(configuration).set_capacity_providers(capacity_providers).send().await?;
-    println!("cluster created: {:?}", cluster);
-
-    Ok(())
+pub async fn create_cluster(client: &Client, name: &String, tags: Option<Vec<Tag>>, settings : Option<Vec<ClusterSetting>>,configuration : ClusterConfiguration, capacity_providers:  Option<Vec<String>>) -> Result<(), Error> {
+    println!("{name}");
+    let res = client.create_cluster().cluster_name(name).set_tags(tags).set_settings(settings).configuration(configuration).set_capacity_providers(capacity_providers).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Created: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
@@ -17,45 +25,70 @@ pub async fn delete_cluster(
     client: &Client,
     name: &String,
 ) -> Result<(), Error> {
-    let cluster_deleted = client.delete_cluster().cluster(name).send().await?;
-    println!("cluster deleted: {:?}", cluster_deleted);
-    
-    Ok(())
+    let res = client.delete_cluster().cluster(name).send().await;
+    match res {
+        Ok(result) =>{
+            println!("Deleted : {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
 pub async fn describe_cluster(client: &Client, clusters: Option<Vec<String>>, include:Option<Vec<ClusterField>>) -> Result<(), Error> {
 
-    let res = client.describe_clusters().set_clusters(clusters).set_include(include).send().await?;
-
-    let clusters = res.clusters();
-    println!("Found {} clusters:", clusters.len());
-    for cluster in clusters {
-        println!("  {}", cluster.cluster_name().unwrap());
-    }
-    Ok(())
+    let res = client.describe_clusters().set_clusters(clusters).set_include(include).send().await;
+    match res {
+        Ok(result) =>{
+            let clusters = result.clusters();
+            println!("Found {} clusters:", clusters.len());
+            for cluster in clusters {
+                println!("  {}", cluster.cluster_name().unwrap());
+            }
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    } 
 }
 
 
 
 pub async fn show_clusters(client: &aws_sdk_ecs::Client, max_results: Option<i32>) -> Result<(), Error> {
-    let resp = client.list_clusters().set_max_results(max_results).send().await?;
-
-    let cluster_arns = resp.cluster_arns();
-    println!("Found {} clusters:", cluster_arns.len());
-
-    let clusters = client
-        .describe_clusters()
-        .set_clusters(Some(cluster_arns.into()))
-        .send()
-        .await?;
-
-    for cluster in clusters.clusters() {
-        println!("  ARN:  {}", cluster.cluster_arn().unwrap());
-        println!("  Name: {}", cluster.cluster_name().unwrap());
+    let res = client.list_clusters().set_max_results(max_results).send().await;
+    match res {
+        Ok(result) =>{
+            let cluster_arns = result.cluster_arns();
+            println!("Found {} clusters:", cluster_arns.len());
+        
+            let clusters = client
+                .describe_clusters()
+                .set_clusters(Some(cluster_arns.into()))
+                .send()
+                .await;
+        
+            if clusters.is_err() {
+                println!("Error: {:?}", clusters.err());
+                return Ok(());
+            }
+            let describe_cluster_result = clusters?;
+            for cluster in describe_cluster_result.clusters() {
+                println!("  ARN:  {}", cluster.cluster_arn().unwrap());
+                println!("  Name: {}", cluster.cluster_name().unwrap());
+            }
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+            Err(e.into())
+        }
     }
-
-    Ok(())
 }
 
 
diff --git a/rustcloud/src/aws/aws_apis/compute/aws_eks.rs b/rustcloud/src/aws/aws_apis/compute/aws_eks.rs
index a1fa9af..af1babc 100644
--- a/rustcloud/src/aws/aws_apis/compute/aws_eks.rs
+++ b/rustcloud/src/aws/aws_apis/compute/aws_eks.rs
@@ -8,11 +8,10 @@ use aws_sdk_eks::types::{AmiTypes, CapacityTypes, KubernetesNetworkConfigRequest
 
 
 
-#[tokio::main]
-#[allow(clippy::result_large_err)]
-pub async fn create_cluster(client: &Client, cluster_name: String,_subnet_id: Vec<String>, version: Option<String>, role_arn: Option<String>, resources_vpc_config: Option<VpcConfigRequest>, kubernetes_network_config: Option<KubernetesNetworkConfigRequest> ) -> Result<(), Error> {
+
+pub async fn create_cluster(client: &Client, cluster_name: String, version: Option<String>, role_arn: Option<String>, resources_vpc_config: Option<VpcConfigRequest>, kubernetes_network_config: Option<KubernetesNetworkConfigRequest> ) -> Result<(), Error> {
     
-    let cluster = client
+    let res = client
         .create_cluster()
         .name(cluster_name)
         .set_role_arn(role_arn)
@@ -20,17 +19,25 @@ pub async fn create_cluster(client: &Client, cluster_name: String,_subnet_id: Ve
         .set_resources_vpc_config(resources_vpc_config)
         .set_kubernetes_network_config(kubernetes_network_config)
         .send()
-        .await?;
-        println!("cluster created: {:?}", cluster);
-        Ok(())
-    // return cluster;
+        .await;
+    match res {
+        Ok(result) =>{
+            println!("cluster created: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
+
 }
 
 
 
 pub async fn create_node_group(client: &Client, cluster_name: String, nodegroup_name: String, disk_size: Option<i32>, scaling_config: Option<NodegroupScalingConfig>, subnets: Option<Vec<String>>, instance_types: Option<Vec<String>>, ami_type: Option<AmiTypes>, remote_access: Option<RemoteAccessConfig>,node_role: Option<String>, labels: Option<HashMap<String,String>>,taints: Option<Vec<Taint>>,tags: Option<HashMap<String, String>>, client_request_token: Option<String>, launch_template: Option<LaunchTemplateSpecification>,update_config: Option<NodegroupUpdateConfig>,capacity_type: Option<CapacityTypes>,version: Option<String>,release_version: Option<String> ) -> Result<(), Error> {
 
-    let node_group = client.create_nodegroup()
+    let resp = client.create_nodegroup()
     .cluster_name(cluster_name)
     .nodegroup_name(nodegroup_name)
     .set_disk_size(disk_size)
@@ -50,79 +57,142 @@ pub async fn create_node_group(client: &Client, cluster_name: String, nodegroup_
     .set_launch_template(launch_template)
     .set_release_version(release_version)
     .send()
-    .await?;
-
-    println!("nodegroup created successfully: {:?}", node_group);
-    Ok(())
+    .await;
+    match resp {
+        Ok(result) =>{        
+            println!("nodegroup created successfully: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
 }
 
 
 
+
 pub async fn delete_nodegroup(client: &Client, cluster_name: String, nodegroup_name: String) -> Result<(), Error> {
-    let nodegroup_deleted = client.delete_nodegroup().cluster_name(cluster_name).nodegroup_name(nodegroup_name).send().await?;
-    println!("nodegroup deleted: {:?}", nodegroup_deleted);
- 
-    Ok(())
+    let resp = client.delete_nodegroup().cluster_name(cluster_name).nodegroup_name(nodegroup_name).send().await;
+    match resp {
+        Ok(result) =>{        
+        
+            println!("nodegroup deleted: {:?}", result);
+         
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
     
 }
 
 pub async fn describe_cluster(client: &Client, name: String) -> Result<(), Error> {
-    let cluster = client.describe_cluster().name(name).send().await?;
-    println!("cluster: {:?}", cluster);
-    Ok(())
+    let resp = client.describe_cluster().name(name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("cluster: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn describe_nodegroup(client: &Client, cluster_name: String, nodegroup_name: String) -> Result<(), Error> {
-    let cluster = client.describe_nodegroup().cluster_name(cluster_name).nodegroup_name(nodegroup_name).send().await?;
-    println!("nodegroup: {:?}", cluster);
-    Ok(())
-    
+    let resp = client.describe_nodegroup().cluster_name(cluster_name).nodegroup_name(nodegroup_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("nodegroup: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
-pub async fn delete_cluster(client: &Client, cluster_name: &str) -> Result<(), DeleteClusterError> {
-    let cluster_deleted = client.delete_cluster().name(cluster_name).send().await;
-    println!("cluster deleted: {:?}", cluster_deleted);
-    Ok(())
+pub async fn delete_cluster(client: &Client, cluster_name: &str) -> Result<(), Error> {
+    let resp = client.delete_cluster().name(cluster_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("cluster deleted: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn list_clusters(client: &Client, max_results: Option<i32>, include: Option<Vec<String>>) -> Result<(), Error> {
 
-    let resp = client.list_clusters().set_max_results(max_results).set_include(include).send().await?;
-    let clusters = resp.clusters();
-    // ListClustersOutput
-    println!("Found {} clusters:", clusters.len());
-
-    for cluster in clusters {
-        println!("  {}", cluster);
+    let resp = client.list_clusters().set_max_results(max_results).set_include(include).send().await;
+    match resp {
+        Ok(result) =>{        
+            let clusters = result.clusters();
+            // ListClustersOutput
+            println!("Found {} clusters:", clusters.len());
+        
+            for cluster in clusters {
+                println!("  {}", cluster);
+            }
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
     }
-
-    Ok(())
 }
 
 pub async fn list_nodegroups(client: &Client, cluster_name: String, max_results: Option<i32>) -> Result<(), Error> {
-    let resp = client.list_nodegroups().cluster_name(cluster_name).set_max_results(max_results).send().await?;
-    let nodegroups = resp.nodegroups();
-    // ListClustersOutput
-    println!("Found {} nodegroups:", nodegroups.len());
-
-    for nodegroup in nodegroups {
-        println!("  {}", nodegroup);
+    let resp = client.list_nodegroups().cluster_name(cluster_name).set_max_results(max_results).send().await;
+    match resp {
+        Ok(result) =>{        
+            let nodegroups = result.nodegroups();
+            // ListClustersOutput
+            println!("Found {} nodegroups:", nodegroups.len());
+        
+            for nodegroup in nodegroups {
+                println!("  {}", nodegroup);
+            }        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
     }
-
-    Ok(())
 }
 
 pub async fn update_tags(client: &Client, resource_arn: String, tags: Option<HashMap<String, String>>) -> Result<(), Error> {
-    let update_tags = client.tag_resource().resource_arn(resource_arn).set_tags(tags).send().await?;
-    println!("tags updated: {:?}", update_tags);
-    Ok(())
+    let resp = client.tag_resource().resource_arn(resource_arn).set_tags(tags).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("tags updated: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
 pub async fn update_config(client: &Client, name: String, resources_vpc_config: Option<VpcConfigRequest>, logging: Option<Logging>, client_request_token: Option<String>, access_config: Option<UpdateAccessConfigRequest>) -> Result<(), Error> {
-    let update_config = 
+    let resp = 
     client
     .update_cluster_config()
     .name(name)
@@ -130,13 +200,16 @@ pub async fn update_config(client: &Client, name: String, resources_vpc_config:
     .set_logging(logging)
     .set_client_request_token(client_request_token)
     .set_access_config(access_config)
-    .send().await?;
-
-    println!("config updated: {:?}", update_config);
-
-    Ok(())
-}
-
-
-
-
+    .send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("config updated: {:?}", result);
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustcloud/src/aws/aws_apis/compute/aws_paas.rs b/rustcloud/src/aws/aws_apis/compute/aws_paas.rs
deleted file mode 100644
index e69de29..0000000
diff --git a/rustcloud/src/aws/aws_apis/database/aws_dynamodb.rs b/rustcloud/src/aws/aws_apis/database/aws_dynamodb.rs
index acc14fa..5379e75 100644
--- a/rustcloud/src/aws/aws_apis/database/aws_dynamodb.rs
+++ b/rustcloud/src/aws/aws_apis/database/aws_dynamodb.rs
@@ -5,47 +5,81 @@ use tokio;
 use aws_sdk_dynamodb::{types::{AttributeDefinition, AttributeValue, BillingMode, Condition, ConditionalOperator, ExpectedAttributeValue, GlobalSecondaryIndex, KeySchemaElement, LocalSecondaryIndex, OnDemandThroughput, ProvisionedThroughput, ReturnConsumedCapacity, ReturnItemCollectionMetrics, ReturnValue, ReturnValuesOnConditionCheckFailure, Select, SseSpecification, StreamSpecification, TableClass, Tag}, Client, Error};
 
 
-#[tokio::main]
-#[allow(clippy::result_large_err)]
-pub async fn create_table(client : &Client, attribute_definitions:AttributeDefinition,table_name: String,key_schema:KeySchemaElement,local_secondary_indexes: LocalSecondaryIndex,global_secondary_index: GlobalSecondaryIndex,billing_mode: BillingMode,provisioned_throughput :ProvisionedThroughput,stream_specification :StreamSpecification,sse_specification :SseSpecification,tags :Option<Vec<Tag>>,
+pub async fn create_table(client : &Client, attribute_definitions:AttributeDefinition,table_name: String,key_schema:KeySchemaElement,local_secondary_indexes: Option<Vec<LocalSecondaryIndex>>,global_secondary_index: Option<Vec<GlobalSecondaryIndex>>,billing_mode: BillingMode,provisioned_throughput :ProvisionedThroughput,stream_specification :Option<StreamSpecification>,sse_specification :Option<SseSpecification>,tags :Option<Vec<Tag>>,
  table_class: TableClass,deletion_protection_enabled: Option<bool>,resource_policy: Option<String>,on_demand_throughput: Option<OnDemandThroughput>) -> Result<(), Error> {
-    let table = client.create_table().attribute_definitions(attribute_definitions).table_name(table_name).key_schema(key_schema).local_secondary_indexes(local_secondary_indexes).global_secondary_indexes(global_secondary_index).billing_mode(billing_mode).provisioned_throughput(provisioned_throughput).stream_specification(stream_specification).sse_specification(sse_specification).set_tags(tags).table_class(table_class).set_deletion_protection_enabled(deletion_protection_enabled).set_resource_policy(resource_policy).set_on_demand_throughput(on_demand_throughput).send().await?;
+    let resp = client.create_table().attribute_definitions(attribute_definitions).table_name(table_name).key_schema(key_schema).set_local_secondary_indexes(local_secondary_indexes).set_global_secondary_indexes(global_secondary_index).billing_mode(billing_mode).provisioned_throughput(provisioned_throughput).set_stream_specification(stream_specification).set_sse_specification(sse_specification).set_tags(tags).table_class(table_class).set_deletion_protection_enabled(deletion_protection_enabled).set_resource_policy(resource_policy).set_on_demand_throughput(on_demand_throughput).send().await;
+    
+    match resp {
+        Ok(result) =>{        
+            println!("table created: {:?}", result);
         
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    println!("table created: {:?}", table);
-
-    Ok(())
 }
 
 
 pub async fn delete_item(client: &Client,   table_name: String, key: Option<HashMap<String, AttributeValue>>, expected: Option<HashMap<String, ExpectedAttributeValue>>, conditional_operator: Option<ConditionalOperator>,  return_values: Option<ReturnValue>, return_consumed_capacity: Option<ReturnConsumedCapacity>, return_item_collection_metrics: Option<ReturnItemCollectionMetrics>, condition_expression: Option<String>, expression_attribute_names: Option<HashMap<String, String>>, expression_attribute_values: Option<HashMap<String, AttributeValue>>,return_values_on_condition_check_failure: Option<ReturnValuesOnConditionCheckFailure>) -> Result<(), Error> {
-    let delete_item = client.delete_item().table_name(table_name).set_key(key).set_expected(expected).set_conditional_operator(conditional_operator).set_return_values(return_values).set_return_consumed_capacity(return_consumed_capacity).set_return_item_collection_metrics(return_item_collection_metrics).set_condition_expression(condition_expression).set_expression_attribute_names(expression_attribute_names).set_return_values_on_condition_check_failure(return_values_on_condition_check_failure).set_expression_attribute_values(expression_attribute_values).send().await?;
-
-    println!("item deleted: {:?}", delete_item);
-
-
-    Ok(())
+    let resp = client.delete_item().table_name(table_name).set_key(key).set_expected(expected).set_conditional_operator(conditional_operator).set_return_values(return_values).set_return_consumed_capacity(return_consumed_capacity).set_return_item_collection_metrics(return_item_collection_metrics).set_condition_expression(condition_expression).set_expression_attribute_names(expression_attribute_names).set_return_values_on_condition_check_failure(return_values_on_condition_check_failure).set_expression_attribute_values(expression_attribute_values).send().await;
+    
+    match resp {
+        Ok(result) =>{        
+        
+            println!("item deleted: {:?}", result);
+        
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
     
 }
 
 
 pub async fn delete_table(client: &Client,   table_name: String) -> Result<(), Error> {
-    let delete_table = client.delete_table().table_name(table_name).send().await?;
+    let resp = client.delete_table().table_name(table_name).send().await;
 
-    println!("table deleted: {:?}", delete_table);
+    match resp {
+        Ok(result) =>{        
+        
+            println!("table deleted: {:?}", result);
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
     
 }
 
 
 pub async fn query(client: &Client, table_name: String, index_name: Option<String>, select: Option<Select>, attributes_to_get: Option<Vec<String>>, limit: Option<i32>, consistent_read: Option<bool>, key_conditions: Option<HashMap<String, Condition>>, query_filter: Option<HashMap<String, Condition>>, conditional_operator: Option<ConditionalOperator>, scan_index_forward: Option<bool>,exclusive_start_key: Option<HashMap<String, AttributeValue>>,return_consumed_capacity: Option<ReturnConsumedCapacity>, projection_expression: Option<String>, filter_expression: Option<String>,key_condition_expression: Option<String>,expression_attribute_names: Option<HashMap<String, String>>,expression_attribute_values: Option<HashMap<String, AttributeValue>>) -> Result<(), Error> {
-    let query = client.query().table_name(table_name).set_index_name(index_name).set_select(select).set_attributes_to_get(attributes_to_get).set_limit(limit).set_consistent_read(consistent_read).set_key_conditions(key_conditions).set_query_filter(query_filter).set_conditional_operator(conditional_operator).set_scan_index_forward(scan_index_forward).set_exclusive_start_key(exclusive_start_key).set_return_consumed_capacity(return_consumed_capacity).set_projection_expression(projection_expression).set_filter_expression(filter_expression).set_key_condition_expression(key_condition_expression).set_expression_attribute_names(expression_attribute_names).set_expression_attribute_values(expression_attribute_values).send().await?;
+    let resp = client.query().table_name(table_name).set_index_name(index_name).set_select(select).set_attributes_to_get(attributes_to_get).set_limit(limit).set_consistent_read(consistent_read).set_key_conditions(key_conditions).set_query_filter(query_filter).set_conditional_operator(conditional_operator).set_scan_index_forward(scan_index_forward).set_exclusive_start_key(exclusive_start_key).set_return_consumed_capacity(return_consumed_capacity).set_projection_expression(projection_expression).set_filter_expression(filter_expression).set_key_condition_expression(key_condition_expression).set_expression_attribute_names(expression_attribute_names).set_expression_attribute_values(expression_attribute_values).send().await;
     
+    match resp {
+        Ok(result) =>{        
+        
+            println!("table queried: {:?}", result);
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    println!("table queried: {:?}", query);
-
-    Ok(())
 }
 
 
diff --git a/rustcloud/src/aws/aws_apis/management/aws_monitoring.rs b/rustcloud/src/aws/aws_apis/management/aws_monitoring.rs
index f7b6d29..1c8161e 100644
--- a/rustcloud/src/aws/aws_apis/management/aws_monitoring.rs
+++ b/rustcloud/src/aws/aws_apis/management/aws_monitoring.rs
@@ -6,32 +6,63 @@ use aws_sdk_cloudwatch::{types::{ComparisonOperator, LabelOptions, MetricDataQue
 
 
 pub async fn delete_alarm(client: &Client, alarm_name: &String) -> Result<(), Error> {
-    let delete_alarm = client.delete_alarms().alarm_names(alarm_name).send().await?;
-    println!("{:?}", delete_alarm);
-    Ok(())
+    let resp = client.delete_alarms().alarm_names(alarm_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
 pub async fn get_metric_data(client: &Client, metric_data_queries:Option<Vec<MetricDataQuery>>,start_time: Option<DateTime>,end_time: Option<DateTime>,next_token: Option<String>,scan_by: Option<ScanBy>,  _max_datapoints: Option<i32>,label_options: Option<LabelOptions>) -> Result<(), Error> {
     
-    let get_metric_data = client.get_metric_data().set_metric_data_queries(metric_data_queries).set_start_time(start_time).set_end_time(end_time).set_next_token(next_token).set_scan_by(scan_by).set_label_options(label_options).send().await?;
-    println!("{:?}", get_metric_data);
-
-    Ok(())
+    let resp = client.get_metric_data().set_metric_data_queries(metric_data_queries).set_start_time(start_time).set_end_time(end_time).set_next_token(next_token).set_scan_by(scan_by).set_label_options(label_options).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+        
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn list_alarms(client: &Client) -> Result<(),Error> {
-    let list_alarms = client.list_metrics().send().await?;
-    println!("{:?}", list_alarms);
-    Ok(())
+    let resp = client.list_metrics().send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn put_metric_alarm(client: &Client, alarm_name: &String, alarm_description: Option<String>, alarm_actions: Option<Vec<String>>, comparison_operator: Option<ComparisonOperator>, evaluation_periods: Option<i32>, metric_name: Option<String>, namespace: Option<String>, period: Option<i32>, statistic: Option<Statistic>, threshold: Option<f64>, treat_missing_data: Option<String>) -> Result<(), Error> {
-    let put_metric_alarm = client.put_metric_alarm().alarm_name(alarm_name).set_alarm_description(alarm_description).set_alarm_actions(alarm_actions).set_comparison_operator(comparison_operator).set_evaluation_periods(evaluation_periods).set_metric_name(metric_name).set_namespace(namespace).set_period(period).set_statistic(statistic).set_threshold(threshold).set_treat_missing_data(treat_missing_data).send().await?;
-
-    println!("{:?}", put_metric_alarm);
-
-
-    Ok(())
+    let resp = client.put_metric_alarm().alarm_name(alarm_name).set_alarm_description(alarm_description).set_alarm_actions(alarm_actions).set_comparison_operator(comparison_operator).set_evaluation_periods(evaluation_periods).set_metric_name(metric_name).set_namespace(namespace).set_period(period).set_statistic(statistic).set_threshold(threshold).set_treat_missing_data(treat_missing_data).send().await;
+    match resp {
+        Ok(result) =>{        
+        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
+    
 }
 
diff --git a/rustcloud/src/aws/aws_apis/network/aws_dns.rs b/rustcloud/src/aws/aws_apis/network/aws_dns.rs
index c17a43a..50aeff4 100644
--- a/rustcloud/src/aws/aws_apis/network/aws_dns.rs
+++ b/rustcloud/src/aws/aws_apis/network/aws_dns.rs
@@ -4,26 +4,59 @@ use aws_sdk_route53::{types::{ChangeBatch, HostedZoneConfig, HostedZoneType, Vpc
 
 
 pub async fn change_record_sets(client: &Client, hosted_zone_id: String, change_batch: ChangeBatch) -> Result<(), Error> {
-    let change_record_sets = client.change_resource_record_sets().hosted_zone_id(hosted_zone_id).change_batch(change_batch).send().await?;
-    println!("{:?}", change_record_sets);
-    Ok(())
+    let resp = client.change_resource_record_sets().hosted_zone_id(hosted_zone_id).change_batch(change_batch).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
     
 }
 
 pub async fn create_zone(client: &Client, name: String, vpc: Vpc, caller_reference: String,hosted_zone_config: Option<HostedZoneConfig>,delegation_set_id: Option<String> ) -> Result<(), Error> {
-    let create_zone = client.create_hosted_zone().name(name).vpc(vpc).caller_reference(caller_reference).set_hosted_zone_config(hosted_zone_config).set_delegation_set_id(delegation_set_id).send().await?;
-    println!("{:?}", create_zone);
-    Ok(())
+    let resp = client.create_hosted_zone().name(name).vpc(vpc).caller_reference(caller_reference).set_hosted_zone_config(hosted_zone_config).set_delegation_set_id(delegation_set_id).send().await;
+    
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
     
 }
 pub async fn delete_zone(client: &Client, id: String) -> Result<(), Error> {
-    let delete_zone = client.delete_hosted_zone().id(id).send().await?;
-    println!("{:?}", delete_zone);
-    Ok(())
+    let resp = client.delete_hosted_zone().id(id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn list_zones(client: &Client, marker: Option<String>,max_items: Option<i32>,delegation_set_id: Option<String>,hosted_zone_type:Option<HostedZoneType>) -> Result<(), Error> {
-    let list_zones = client.list_hosted_zones().set_marker(marker).set_max_items(max_items).set_hosted_zone_type(hosted_zone_type).set_delegation_set_id(delegation_set_id).send().await?;
-    println!("{:?}", list_zones);
-    Ok(())
+    let resp = client.list_hosted_zones().set_marker(marker).set_max_items(max_items).set_hosted_zone_type(hosted_zone_type).set_delegation_set_id(delegation_set_id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
\ No newline at end of file
diff --git a/rustcloud/src/aws/aws_apis/network/aws_loadbalancer.rs b/rustcloud/src/aws/aws_apis/network/aws_loadbalancer.rs
index 9ace736..bf6976f 100644
--- a/rustcloud/src/aws/aws_apis/network/aws_loadbalancer.rs
+++ b/rustcloud/src/aws/aws_apis/network/aws_loadbalancer.rs
@@ -4,33 +4,74 @@ use aws_sdk_elasticloadbalancing::{types::{Listener, Tag}, Client, Error};
 
 
 pub async fn add_tags(client: &Client, load_balancer_name: String, tags: Tag) -> Result<(), Error> {
-    let add_tags = client.add_tags().load_balancer_names(load_balancer_name).tags(tags).send().await?;
-    println!("{:?}", add_tags);
-    Ok(())
+    let resp = client.add_tags().load_balancer_names(load_balancer_name).tags(tags).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
+
 }
 
 
 pub async fn create(client: &Client, load_balancer_name: String,listeners: Option<Vec<Listener>>,availability_zones: Option<Vec<String>>,subnets: Option<Vec<String>>,security_groups: Option<Vec<String>>,scheme: Option<String>,tags: Option<Vec<Tag>>) -> Result<(), Error> {
-    let create = client.create_load_balancer().load_balancer_name(load_balancer_name).set_listeners(listeners).set_availability_zones(availability_zones).set_security_groups(security_groups).set_scheme(scheme).set_tags(tags).set_subnets(subnets).send().await?;
-    println!("{:?}", create);
-    Ok(())
+    let resp = client.create_load_balancer().load_balancer_name(load_balancer_name).set_listeners(listeners).set_availability_zones(availability_zones).set_security_groups(security_groups).set_scheme(scheme).set_tags(tags).set_subnets(subnets).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
     
 }
 
 pub async fn delete(client: &Client, load_balancer_name: String) -> Result<(), Error> {
-    let delete = client.delete_load_balancer().load_balancer_name(load_balancer_name).send().await?;
-    println!("{:?}", delete);
-    Ok(())
+    let resp = client.delete_load_balancer().load_balancer_name(load_balancer_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn describe(client: &Client, load_balancer_name: String) -> Result<(), Error> {
-    let describe = client.describe_load_balancer_attributes().load_balancer_name(load_balancer_name).send().await?;
-    println!("{:?}", describe);
-    Ok(())
+    let resp = client.describe_load_balancer_attributes().load_balancer_name(load_balancer_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 pub async fn list_load_balancers(client: &Client, load_balancer_names: String,marker: String,page_size: i32) -> Result<(), Error> {
-    let list_load_balancers = client.describe_load_balancers().load_balancer_names(load_balancer_names).marker(marker).page_size(page_size).send().await?;
-    println!("{:?}", list_load_balancers);
-    Ok(())
+    let resp = client.describe_load_balancers().load_balancer_names(load_balancer_names).marker(marker).page_size(page_size).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("{:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
diff --git a/rustcloud/src/aws/aws_apis/security/aws_iam.rs b/rustcloud/src/aws/aws_apis/security/aws_iam.rs
index 088dce1..cb6097e 100644
--- a/rustcloud/src/aws/aws_apis/security/aws_iam.rs
+++ b/rustcloud/src/aws/aws_apis/security/aws_iam.rs
@@ -4,37 +4,72 @@ use aws_sdk_iam::{Client, Error};
 
 
 pub async fn attach_group_policy(client: &Client, group_name: String, policy_arn: String) -> Result<(), Error> {
-    let attachgrouppolicy = client.attach_group_policy().group_name(group_name).policy_arn(policy_arn).send().await?;
-    println!("attachgrouppolicy: {:?}", attachgrouppolicy);
-    Ok(())
+    let resp = client.attach_group_policy().group_name(group_name).policy_arn(policy_arn).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("attachgrouppolicy: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
 }
 
-pub struct CreateGroupInput {
-    pub path: Option<String>,
-    pub group_name: Option<String>,
-}
-
 pub async fn create_group(client: &Client, path: String, group_name: String) -> Result<(), Error> {
-    let creategroup = client.create_group().group_name(path).group_name(group_name).send().await?;
-    println!("creategroup: {:?}", creategroup);
-    Ok(())
+    let resp = client.create_group().group_name(path).group_name(group_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("creategroup: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn delete_group(client: &Client, group_name: String) -> Result<(), Error> {
-    let deletegroup = client.delete_group().group_name(group_name).send().await?;
-    println!("deletegroup: {:?}", deletegroup);
-    Ok(())
+    let resp = client.delete_group().group_name(group_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("deletegroup: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn detach_group_policy(client: &Client, group_name: String, policy_arn: String) -> Result<(), Error> {
-    let detachgrouppolicy = client.detach_group_policy().group_name(group_name).policy_arn(policy_arn).send().await?;
-    println!("detachgrouppolicy: {:?}", detachgrouppolicy);
-    Ok(())
+    let resp = client.detach_group_policy().group_name(group_name).policy_arn(policy_arn).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("detachgrouppolicy: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
-pub async fn describe(client: &Client, group_name: String, marker: String, max_items: i32) -> Result<(), Error> {
-    let describe = client.get_group().group_name(group_name).marker(marker).max_items(max_items).send().await?;
-    println!("describe: {:?}", describe);
-    Ok(())
+pub async fn describe(client: &Client, group_name: String, marker: Option<String>, max_items: Option<i32>) -> Result<(), Error> {
+    let resp = client.get_group().group_name(group_name).set_marker(marker).set_max_items(max_items).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("describe: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
diff --git a/rustcloud/src/aws/aws_apis/security/aws_keymanagement.rs b/rustcloud/src/aws/aws_apis/security/aws_keymanagement.rs
index 1a6bb82..a8124b2 100644
--- a/rustcloud/src/aws/aws_apis/security/aws_keymanagement.rs
+++ b/rustcloud/src/aws/aws_apis/security/aws_keymanagement.rs
@@ -4,31 +4,71 @@ use aws_sdk_kms::{types::{KeySpec, KeyUsageType, OriginType, Tag}, Client, Error
 
 
 pub async fn create_key(client: &Client, policy: String,description: Option<String>,key_usage: Option<KeyUsageType>,key_spec: Option<KeySpec>,origin: Option<OriginType>,custom_key_store_id: Option<String>,bypass_policy_lockout_safety_check: Option<bool>,tags: Option<Vec<Tag>>,multi_region: Option<bool>,xks_key_id: Option<String>) -> Result<(), Error> {
-    let createkey = client.create_key().policy(policy).set_description(description).set_key_usage(key_usage).set_origin(origin).set_key_spec(key_spec).set_custom_key_store_id(custom_key_store_id).set_bypass_policy_lockout_safety_check(bypass_policy_lockout_safety_check).set_tags(tags).set_multi_region(multi_region).set_xks_key_id(xks_key_id).send().await?;
-    println!("createkey: {:?}", createkey);
-    Ok(())
+    let resp = client.create_key().policy(policy).set_description(description).set_key_usage(key_usage).set_origin(origin).set_key_spec(key_spec).set_custom_key_store_id(custom_key_store_id).set_bypass_policy_lockout_safety_check(bypass_policy_lockout_safety_check).set_tags(tags).set_multi_region(multi_region).set_xks_key_id(xks_key_id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("createkey: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn delete_key(client: &Client, custom_key_store_id: String) -> Result<(), Error> {
-    let deletekey = client.delete_custom_key_store().custom_key_store_id(custom_key_store_id).send().await?;
-    println!("deletekey: {:?}", deletekey);
-    Ok(())
+    let resp = client.delete_custom_key_store().custom_key_store_id(custom_key_store_id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("deletekey: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn describe_key(client: &Client, key_id: String, grant_tokens: Option<Vec<String>>) -> Result<(), Error> {
-    let describekey = client.describe_key().key_id(key_id).set_grant_tokens(grant_tokens).send().await?;
-    println!("describekey: {:?}", describekey);
-    Ok(())
+    let resp = client.describe_key().key_id(key_id).set_grant_tokens(grant_tokens).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("describekey: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn put_key_policy(client: &Client, key_id: String, policy_name: String, policy: String, bypass_policy_lockout_safety_check: Option<bool>) -> Result<(), Error> {
-    let putkeypolicy = client.put_key_policy().key_id(key_id).policy(policy).policy_name(policy_name).set_bypass_policy_lockout_safety_check(bypass_policy_lockout_safety_check).send().await?;
-    println!("putkeypolicy: {:?}", putkeypolicy);
-    Ok(())
+    let resp = client.put_key_policy().key_id(key_id).policy(policy).policy_name(policy_name).set_bypass_policy_lockout_safety_check(bypass_policy_lockout_safety_check).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("putkeypolicy: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn update(client: &Client, key_id: String, description: Option<String>) -> Result<(), Error> {
-    let update = client.update_key_description().key_id(key_id).set_description(description).send().await?;
-    println!("update: {:?}", update);
-    Ok(())
+    let resp = client.update_key_description().key_id(key_id).set_description(description).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("update: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
\ No newline at end of file
diff --git a/rustcloud/src/aws/aws_apis/storage/aws_archival_storage.rs b/rustcloud/src/aws/aws_apis/storage/aws_archival_storage.rs
index 4c018a8..1601c5b 100644
--- a/rustcloud/src/aws/aws_apis/storage/aws_archival_storage.rs
+++ b/rustcloud/src/aws/aws_apis/storage/aws_archival_storage.rs
@@ -4,35 +4,75 @@ use aws_sdk_glacier::{Client, Error};
 
 
 pub async fn create_vault(client: &Client, vault_name: String, account_id: String) -> Result<(), Error> {
-    let createvault = client.create_vault().vault_name(vault_name).account_id(account_id).send().await?;
-    println!("createvault: {:?}", createvault);
-    Ok(())
+    let resp = client.create_vault().vault_name(vault_name).account_id(account_id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("createvault: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
 pub async fn delete_archive(client: &Client, account_id: String, vault_name: String, archive_id: String) -> Result<(), Error> {
-    let deletearchive = client.delete_archive().account_id(account_id).vault_name(vault_name).archive_id(archive_id).send().await?;
-    println!("deletearchive: {:?}", deletearchive);
-    Ok(())
+    let resp = client.delete_archive().account_id(account_id).vault_name(vault_name).archive_id(archive_id).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("deletearchive: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn delete_vault(client: &Client, account_id: String, vault_name: String) -> Result<(), Error> {
-    let deletevault = client.delete_vault().account_id(account_id).vault_name(vault_name).send().await?;
-    println!("deletevault: {:?}", deletevault);
-    Ok(())
+    let resp = client.delete_vault().account_id(account_id).vault_name(vault_name).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("deletevault: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
 pub async fn upload(client: &Client, account_id: String, vault_name: String, archive_description: Option<String>, part_size: Option<String>) -> Result<(), Error> {
-    let upload = client.initiate_multipart_upload().account_id(account_id).vault_name(vault_name).set_archive_description(archive_description).set_part_size(part_size).send().await?;
-    println!("upload: {:?}", upload);
-    Ok(())
+    let resp = client.initiate_multipart_upload().account_id(account_id).vault_name(vault_name).set_archive_description(archive_description).set_part_size(part_size).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("upload: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 pub async fn list(client: &Client,account_id: String, marker: Option<String>, limit: Option<i32>) -> Result<(), Error> {
-    let list = client.list_vaults().account_id(account_id).set_marker(marker).set_limit(limit).send().await?;
-    println!("list: {:?}", list);
-    Ok(())
+    let resp = client.list_vaults().account_id(account_id).set_marker(marker).set_limit(limit).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("list: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
diff --git a/rustcloud/src/aws/aws_apis/storage/aws_block_storage.rs b/rustcloud/src/aws/aws_apis/storage/aws_block_storage.rs
index b2ea0c0..262e99f 100644
--- a/rustcloud/src/aws/aws_apis/storage/aws_block_storage.rs
+++ b/rustcloud/src/aws/aws_apis/storage/aws_block_storage.rs
@@ -19,9 +19,18 @@ pub async fn create(
         .set_encrypted(encrypted)
         .set_kms_key_id(kms_key_id)
         .send()
-        .await?;
+        .await;
+    match resp {
+        Ok(result) =>{        
+            println!("create: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
 }
 
 pub async fn delete(client: &Client, volume_id: String) -> Result<(), Error> {
@@ -29,9 +38,18 @@ pub async fn delete(client: &Client, volume_id: String) -> Result<(), Error> {
         .delete_volume()
         .volume_id(volume_id)
         .send()
-        .await?;
+        .await;
+    match resp {
+        Ok(result) =>{        
+            println!("delete: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
 }
 
 pub async fn describe(
@@ -44,9 +62,18 @@ pub async fn describe(
         .volume_id(volume_id)
         .attribute(attribute)
         .send()
-        .await?;
+        .await;
+    match resp {
+        Ok(result) =>{        
+            println!("describe: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
 }
 
 pub async fn list(
@@ -71,7 +98,16 @@ pub async fn list(
         request = request.next_token(token);
     }
 
-    let resp = request.send().await?;
+    let resp = request.send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("descibe: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 
-    Ok(())
 }
\ No newline at end of file
diff --git a/rustcloud/src/aws/aws_apis/storage/aws_storage_bucket.rs b/rustcloud/src/aws/aws_apis/storage/aws_storage_bucket.rs
index b20efbd..d1b7655 100644
--- a/rustcloud/src/aws/aws_apis/storage/aws_storage_bucket.rs
+++ b/rustcloud/src/aws/aws_apis/storage/aws_storage_bucket.rs
@@ -2,30 +2,62 @@
 
 use aws_sdk_s3::{types::{BucketCannedAcl, CreateBucketConfiguration, ObjectOwnership, RequestPayer}, Client, Error};
 
-async fn create_bucket(client: &Client, acl: BucketCannedAcl,bucket: String,create_bucket_configuration: CreateBucketConfiguration,grant_full_control: Option<String>,grant_read: Option<String>,grant_read_acp: Option<String>,grant_write: Option<String>,grant_write_acp: Option<String>,object_lock_enabled_for_bucket: Option<bool>,object_ownership: Option<ObjectOwnership>) -> Result<(), Error> {
-    let createbucket = client.create_bucket().acl(acl).bucket(bucket).create_bucket_configuration(create_bucket_configuration).set_grant_full_control(grant_full_control).set_grant_read(grant_read).set_grant_read_acp(grant_read_acp).set_grant_write(grant_write).set_grant_write_acp(grant_write_acp).set_object_lock_enabled_for_bucket(object_lock_enabled_for_bucket).set_object_ownership(object_ownership).send().await?;
-    println!("createbucket: {:?}", createbucket);
-    Ok(())
+pub async fn create_bucket(client: &Client, acl: BucketCannedAcl,bucket: String,create_bucket_configuration: CreateBucketConfiguration,grant_full_control: Option<String>,grant_read: Option<String>,grant_read_acp: Option<String>,grant_write: Option<String>,grant_write_acp: Option<String>,object_lock_enabled_for_bucket: Option<bool>,object_ownership: Option<ObjectOwnership>) -> Result<(), Error> {
+    let resp = client.create_bucket().acl(acl).bucket(bucket).create_bucket_configuration(create_bucket_configuration).set_grant_full_control(grant_full_control).set_grant_read(grant_read).set_grant_read_acp(grant_read_acp).set_grant_write(grant_write).set_grant_write_acp(grant_write_acp).set_object_lock_enabled_for_bucket(object_lock_enabled_for_bucket).set_object_ownership(object_ownership).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("createbucket: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
-async fn delete(client: &Client, bucket: String, expected_bucket_owner: Option<String>) -> Result<(), Error> {
-    let delete = client.delete_bucket().bucket(bucket).set_expected_bucket_owner(expected_bucket_owner).send().await?;
-    println!("delete: {:?}", delete);
-    Ok(())
+pub async fn delete(client: &Client, bucket: String, expected_bucket_owner: Option<String>) -> Result<(), Error> {
+    let resp = client.delete_bucket().bucket(bucket).set_expected_bucket_owner(expected_bucket_owner).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("delete: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
-async fn delete_object(client: &Client, bucket: String, key: String, expected_bucket_owner: Option<String>, mfa: Option<String>, version_id: Option<String>, request_payer: Option<RequestPayer>) -> Result<(), Error> {
-    let deleteobject = client.delete_object().bucket(bucket).key(key).set_expected_bucket_owner(expected_bucket_owner).set_mfa(mfa).set_version_id(version_id).set_request_payer(request_payer).send().await?;
-    println!("deleteobject: {:?}", deleteobject);
-    Ok(())
+pub async fn delete_object(client: &Client, bucket: String, key: String, expected_bucket_owner: Option<String>, mfa: Option<String>, version_id: Option<String>, request_payer: Option<RequestPayer>) -> Result<(), Error> {
+    let resp = client.delete_object().bucket(bucket).key(key).set_expected_bucket_owner(expected_bucket_owner).set_mfa(mfa).set_version_id(version_id).set_request_payer(request_payer).send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("deleteobject: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 
-async fn list(client: &Client) -> Result<(), Error> {
-    let list = client.list_buckets().send().await?;
-    println!("list: {:?}", list);
-    Ok(())
+pub async fn list(client: &Client) -> Result<(), Error> {
+    let resp = client.list_buckets().send().await;
+    match resp {
+        Ok(result) =>{        
+            println!("list: {:?}", result);
+            Ok(())
+        }
+        Err(e) => {
+            println!("Error : {:?}", e);
+            Err(e.into())
+        }
+    }
 }
 
 // async fn upload(client: &Client, body: ::aws_smithy_types::byte_stream::ByteStream,bucket: Option<String>,content_length: Option<i64>,content_md5: Option<String>,checksum_algorithm: Option<ChecksumAlgorithm>,checksum_crc32: Option<String>,checksum_crc32_c: Option<String>,checksum_sha1: Option<String>,checksum_sha256: Option<String>,key: Option<String>,part_number: Option<i32>,upload_id: Option<String>,sse_customer_algorithm: Option<String>,sse_customer_key: Option<String>,sse_customer_key_md5: Option<String>,request_payer: Option<RequestPayer>,expected_bucket_owner: Option<String>) -> Result<(), Error> {
diff --git a/rustcloud/src/main.rs b/rustcloud/src/main.rs
index 901a713..98d53fd 100644
--- a/rustcloud/src/main.rs
+++ b/rustcloud/src/main.rs
@@ -5,7 +5,6 @@ pub mod aws{
             pub mod aws_ec2;
             pub mod aws_ecs;
             pub mod aws_eks;
-            pub mod aws_paas;
         }
         pub mod database {
             pub mod aws_dynamodb;
diff --git a/rustcloud/src/tests/archival_operations.rs b/rustcloud/src/tests/archival_operations.rs
index 441a1ac..891a593 100644
--- a/rustcloud/src/tests/archival_operations.rs
+++ b/rustcloud/src/tests/archival_operations.rs
@@ -2,13 +2,19 @@ use crate::aws::aws_apis::storage::aws_archival_storage::*;
 use aws_sdk_glacier::{Client, Config};
 use aws_sdk_glacier::config::Region;
 
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
 #[tokio::test]
 async fn test_create_vault() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let vault_name = "test-vault";
-    let account_id = "123456789012";
+    let account_id = "167355850481";
 
     let result = create_vault(&client, vault_name.to_string(), account_id.to_string()).await;
     assert!(result.is_ok());
@@ -16,10 +22,9 @@ async fn test_create_vault() {
 
 #[tokio::test]
 async fn test_delete_archive() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let account_id = "123456789012";
+    let account_id = "167355850481";
     let vault_name = "test-vault";
     let archive_id = "archive123";
 
@@ -29,10 +34,9 @@ async fn test_delete_archive() {
 
 #[tokio::test]
 async fn test_delete_vault() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let account_id = "123456789012";
+    let account_id = "167355850481";
     let vault_name = "test-vault";
 
     let result = delete_vault(&client, account_id.to_string(), vault_name.to_string()).await;
@@ -40,11 +44,10 @@ async fn test_delete_vault() {
 }
 
 #[tokio::test]
-async fn test_upload() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_upload_vault() {
+    let client = create_client().await;
 
-    let account_id = "123456789012";
+    let account_id = "167355850481";
     let vault_name = "test-vault";
     let archive_description = Some("Test archive".to_string());
     let part_size = Some("1048576".to_string());
@@ -54,11 +57,10 @@ async fn test_upload() {
 }
 
 #[tokio::test]
-async fn test_list() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_list_vault() {
+    let client = create_client().await;
 
-    let account_id = "123456789012";
+    let account_id = "167355850481";
     let marker = None;
     let limit = Some(10);
 
diff --git a/rustcloud/src/tests/block_operations.rs b/rustcloud/src/tests/block_operations.rs
index 09045bb..b7ea951 100644
--- a/rustcloud/src/tests/block_operations.rs
+++ b/rustcloud/src/tests/block_operations.rs
@@ -3,15 +3,21 @@ use aws_sdk_ec2::config::Region;
 use aws_sdk_ec2::types::{VolumeType, VolumeAttributeName};
 use crate::aws::aws_apis::storage::aws_block_storage::*;
 
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
 #[tokio::test]
 async fn test_create_volume() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let availability_zone = "us-east-1a".to_string();
+    let availability_zone = "us-west-2a".to_string();
     let size = Some(8); // 8 GiB
     let volume_type = Some(VolumeType::Gp2);
-    let iops = Some(100);
+    let iops = None;
     let encrypted = Some(false);
     let kms_key_id = None;
 
@@ -21,10 +27,9 @@ async fn test_create_volume() {
 
 #[tokio::test]
 async fn test_delete_volume() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let volume_id = "vol-1234567890abcdef0".to_string(); // Replace with a valid volume ID
+    let volume_id = "vol-07694e76f841d98cd".to_string(); // Replace with a valid volume ID
 
     let result = delete(&client, volume_id).await;
     assert!(result.is_ok());
@@ -32,10 +37,9 @@ async fn test_delete_volume() {
 
 #[tokio::test]
 async fn test_describe_volume() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let volume_id = "vol-1234567890abcdef0".to_string(); // Replace with a valid volume ID
+    let volume_id = "vol-07694e76f841d98cd".to_string(); // Replace with a valid volume ID
     let attribute = VolumeAttributeName::AutoEnableIo;
 
     let result = describe(&client, volume_id, attribute).await;
@@ -44,8 +48,7 @@ async fn test_describe_volume() {
 
 #[tokio::test]
 async fn test_list_volumes() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let volume_ids = None; // Optionally provide a list of volume IDs
     let filters = None; // Optionally provide filters
diff --git a/rustcloud/src/tests/bucket_operations.rs b/rustcloud/src/tests/bucket_operations.rs
new file mode 100644
index 0000000..2cb2b3e
--- /dev/null
+++ b/rustcloud/src/tests/bucket_operations.rs
@@ -0,0 +1,78 @@
+use aws_sdk_s3::{types::{BucketCannedAcl, CreateBucketConfiguration, ObjectOwnership, RequestPayer}, Client, Error};
+use aws_sdk_s3::config::Region;
+use tokio;
+use crate::aws::aws_apis::storage::aws_storage_bucket::*;
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
+#[tokio::test]
+async fn test_create_bucket() {
+    let client = create_client().await;
+    let acl = BucketCannedAcl::PublicRead;
+    let bucket = "test-bucket".to_string();
+    let create_bucket_configuration = CreateBucketConfiguration::builder()
+        .location_constraint(aws_sdk_s3::types::BucketLocationConstraint::UsWest2)
+        .build();
+    let grant_full_control = None;
+    let grant_read = None;
+    let grant_read_acp = None;
+    let grant_write = None;
+    let grant_write_acp = None;
+    let object_lock_enabled_for_bucket = None;
+    let object_ownership = None;
+
+    let result = create_bucket(
+        &client,
+        acl,
+        bucket,
+        create_bucket_configuration,
+        grant_full_control,
+        grant_read,
+        grant_read_acp,
+        grant_write,
+        grant_write_acp,
+        object_lock_enabled_for_bucket,
+        object_ownership,
+    ).await;
+
+    assert!(result.is_ok());
+
+}
+
+#[tokio::test]
+async fn test_delete_bucket() {
+    let client = create_client().await;
+    let bucket = "test-bucket".to_string();
+
+    let result = delete(&client, bucket.clone(), None).await;
+
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn test_delete_object() {
+    let client = create_client().await;
+    let bucket = "test-bucket".to_string();
+    let key = "test-object".to_string();
+
+    let result = delete_object(&client, bucket.clone(), key.clone(), None, None, None, None).await;
+
+    assert!(result.is_ok());
+
+    // Clean up
+    delete(&client, bucket, None).await.unwrap();
+}
+
+#[tokio::test]
+async fn test_list_buckets() {
+    let client = create_client().await;
+
+    let result = list(&client).await;
+
+    assert!(result.is_ok());
+}
+
diff --git a/rustcloud/src/tests/dns_operations.rs b/rustcloud/src/tests/dns_operations.rs
index 4dc1578..4640a74 100644
--- a/rustcloud/src/tests/dns_operations.rs
+++ b/rustcloud/src/tests/dns_operations.rs
@@ -3,47 +3,47 @@ use aws_config::meta::region::RegionProviderChain;
 use aws_sdk_route53::{config::Config, types::{builders::ResourceRecordSetBuilder, Change, ChangeAction, ResourceRecord, ResourceRecordSet, RrType, Vpc, VpcRegion}, Client};
 use aws_sdk_route53::types::{ChangeBatch, HostedZoneConfig, HostedZoneType};
 
-async fn get_client() -> Client {
-    let region_provider = RegionProviderChain::default_provider().or_else("us-east-1");
-    let config = aws_config::from_env().region(region_provider).load().await;
-    Client::new(&config)
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
 }
 
 #[tokio::test]
-    async fn test_change_record_sets() {
-        let client = get_client().await;
-
-        let hosted_zone_id = "your_hosted_zone_id".to_string(); // Replace with your hosted zone ID
-
-        // Build ResourceRecord
-        let resource_record = ResourceRecord::builder().value("192.0.2.44".to_string()).build().unwrap();
-        // Build ResourceRecordSet
-        let resource_record_set = ResourceRecordSetBuilder::default()
-            .name("test.example.com.".to_string())
-            .r#type(RrType::A)
-            .ttl(60)
-            .resource_records(resource_record)
-            .build()
-            .expect("Failed to build ResourceRecordSet");
-
-        // Build Change
-        let change = Change::builder()
-            .action(ChangeAction::Upsert)
-            .resource_record_set(resource_record_set.clone()) // Use clone() if needed
-            .build().unwrap();
-
-        // Build ChangeBatch
-        let change_batch = ChangeBatch::builder()
-            .changes(change)
-            .build().unwrap();
-
-        let result = change_record_sets(&client, hosted_zone_id, change_batch).await;
-        assert!(result.is_ok());
-    }
+async fn test_change_record_sets() {
+    let client = create_client().await;
+
+    let hosted_zone_id = "your_hosted_zone_id".to_string(); // Replace with your hosted zone ID
+
+    let resource_record = ResourceRecord::builder().value("192.0.2.44".to_string()).build().unwrap();
+    // Build ResourceRecordSet
+    let resource_record_set = ResourceRecordSetBuilder::default()
+        .name("test.example.com.".to_string())
+        .r#type(RrType::A)
+        .ttl(60)
+        .resource_records(resource_record)
+        .build()
+        .expect("Failed to build ResourceRecordSet");
+
+    // Build Change
+    let change = Change::builder()
+        .action(ChangeAction::Upsert)
+        .resource_record_set(resource_record_set.clone()) // Use clone() if needed
+        .build().unwrap();
+
+    // Build ChangeBatch
+    let change_batch = ChangeBatch::builder()
+        .changes(change)
+        .build().unwrap();
+
+    let result = change_record_sets(&client, hosted_zone_id, change_batch).await;
+    assert!(result.is_ok());
+}
 
 #[tokio::test]
 async fn test_create_zone() {
-    let client = get_client().await;
+    let client = create_client().await;
 
     let name = "example.com".to_string(); // Replace with your desired domain name
     let vpc = Vpc::builder()
@@ -64,7 +64,7 @@ async fn test_create_zone() {
 
 #[tokio::test]
 async fn test_delete_zone() {
-    let client = get_client().await;
+    let client = create_client().await;
 
     let hosted_zone_id = "Z3AADJGX6KTTL2".to_string(); // Replace with your hosted zone ID
 
@@ -74,7 +74,7 @@ async fn test_delete_zone() {
 
 #[tokio::test]
 async fn test_list_zones() {
-    let client = get_client().await;
+    let client = create_client().await;
 
     let marker = None;
     let max_items = Some(10);
diff --git a/rustcloud/src/tests/dynamodb_operations.rs b/rustcloud/src/tests/dynamodb_operations.rs
index 9098e3e..78ca4c9 100644
--- a/rustcloud/src/tests/dynamodb_operations.rs
+++ b/rustcloud/src/tests/dynamodb_operations.rs
@@ -5,11 +5,17 @@ use aws_sdk_dynamodb::types::{AttributeDefinition, AttributeValue, BillingMode,
 };
 use std::collections::HashMap;
 
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
 #[tokio::test]
 async fn test_create_table() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-    
+    let client = create_client().await;
+
     let table_name = "test-table".to_string();
     let attribute_definitions = AttributeDefinition::builder()
         .attribute_name("id")
@@ -30,26 +36,25 @@ async fn test_create_table() {
         attribute_definitions,
         table_name,
         key_schema,
-        LocalSecondaryIndex::builder().build().unwrap(),  // LocalSecondaryIndex
-        GlobalSecondaryIndex::builder().build().unwrap(),  // GlobalSecondaryIndex
+        None,
+        None,
         BillingMode::Provisioned,
         provisioned_throughput,
-        StreamSpecification::builder().build().unwrap(),
-        SseSpecification::builder().build(),
+        None,
+        None,
         None,  // tags
         TableClass::Standard,
         Some(false),  // deletion_protection_enabled
         None,  // resource_policy
         None,  // on_demand_throughput
-    );
+    ).await;
     
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_delete_item() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let table_name = "test-table".to_string();
     let mut key = HashMap::new();
@@ -75,8 +80,7 @@ async fn test_delete_item() {
 
 #[tokio::test]
 async fn test_delete_table() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let table_name = "test-table".to_string();
 
@@ -87,8 +91,7 @@ async fn test_delete_table() {
 
 #[tokio::test]
 async fn test_query() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let table_name = "test-table".to_string();
     let mut key_conditions = HashMap::new();
diff --git a/rustcloud/src/tests/ec2_operations.rs b/rustcloud/src/tests/ec2_operations.rs
index 81781d0..6c46a0b 100644
--- a/rustcloud/src/tests/ec2_operations.rs
+++ b/rustcloud/src/tests/ec2_operations.rs
@@ -1,29 +1,28 @@
 use crate::aws::aws_apis::compute::aws_ec2::*;
-
+use aws_config::BehaviorVersion;
 use aws_sdk_ec2::{Client, Config};
 use aws_sdk_ec2::config::Region;
-// use aws_sdk_ec2::config::Region;
+use aws_config::meta::region::RegionProviderChain;
+
 
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
 
 #[tokio::test]
 async fn test_create_instance() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-
-    let ami_id = "ami-1234567890abcdef0"; // Replace with a valid AMI ID
-
+    let client = create_client().await;
+    let ami_id = "ami-0aff18ec83b712f05";
     let result = create_instance(&client, ami_id).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_show_state() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-
-    // Optionally provide instance IDs to test specific instances
-    let ids = None;
-
+    let client = create_client().await;
+    let ids =  Some((vec!["i-0a06238e5fc156e3f".to_string()]));
     let result = show_state(&client, ids).await;
     assert!(result.is_ok());
 }
@@ -31,19 +30,16 @@ async fn test_show_state() {
 
 #[tokio::test]
 async fn test_show_all_events() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-
+    let client = create_client().await;
     let result = show_all_events(&client).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_enable_monitoring() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let instance_id = "i-1234567890abcdef0"; // Replace with a valid instance ID
+    let instance_id = "i-0a06238e5fc156e3f";
 
     let result = enable_monitoring(&client, instance_id).await;
     assert!(result.is_ok());
@@ -51,32 +47,30 @@ async fn test_enable_monitoring() {
 
 #[tokio::test]
 async fn test_reboot_instance() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-
-    let instance_id = "i-1234567890abcdef0"; // Replace with a valid instance ID
-
+    let client = create_client().await;
+    
+    
+    let instance_id = "i-0a06238e5fc156e3f"; // Replace with a valid instance ID
+    
     let result = reboot_instance(&client, instance_id).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_start_instance() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
-
-    let instance_id = "i-1234567890abcdef0";
-
+    let client = create_client().await;
+    
+    let instance_id = "i-0a06238e5fc156e3f";
+    
     let result = start_instance(&client, instance_id).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_stop_instance() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let instance_id = "i-1234567890abcdef0"; // Replace with a valid instance ID
+    let instance_id = "i-0a06238e5fc156e3f"; // Replace with a valid instance ID
 
     let result = stop_instance(&client, instance_id).await;
     assert!(result.is_ok());
diff --git a/rustcloud/src/tests/ecs_operations.rs b/rustcloud/src/tests/ecs_operations.rs
index 2cb09eb..7491d3c 100644
--- a/rustcloud/src/tests/ecs_operations.rs
+++ b/rustcloud/src/tests/ecs_operations.rs
@@ -3,23 +3,26 @@ use crate::aws::aws_apis::compute::aws_ecs::*;
 use aws_sdk_ecs::{Client, Config};
 use aws_sdk_ecs::config::Region;
 use aws_sdk_ecs::types::{ClusterConfiguration, ClusterSetting, Tag, ClusterSettingName};
+use aws_config;
 
-
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
 #[tokio::test]
-async fn test_create_cluster() {
-    // Replace with your AWS credentials and desired region
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_create_ecs_cluster() {
+    let client = create_client().await;
 
     let name = "test-cluster".to_string();
     let tags = Some(vec![
         Tag::builder().key("Environment").value("Test").build(),
         Tag::builder().key("Name").value("Test Cluster").build(),
     ]);
-    let settings = ClusterSetting::builder()
-    .name(ClusterSettingName::from("my-cluster-setting"))
-    .value("some-value")
-    .build(); // Replace with your desired settings
+    // let settings = ClusterSetting::builder()
+    // .value("some-value")
+    // .build(); // Replace with your desired settings
+    let settings  = None;
     let configuration = ClusterConfiguration::builder().build(); // Replace with your desired configuration
     let capacity_providers = None; // Replace with your desired capacity providers if any
 
@@ -28,10 +31,8 @@ async fn test_create_cluster() {
 }
 
 #[tokio::test]
-async fn test_delete_cluster() {
-    // Replace with your AWS credentials and desired region
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_delete_ecs_cluster() {
+    let client = create_client().await;
 
     let name = "test-cluster".to_string(); // Replace with an existing cluster name
 
@@ -40,12 +41,11 @@ async fn test_delete_cluster() {
 }
 
 #[tokio::test]
-async fn test_describe_cluster() {
-    // Replace with your AWS credentials and desired region
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_describe_ecs_cluster() {
+    let client = create_client().await;
 
-    let clusters = None; // Optionally specify cluster names to describe
+
+    let clusters = Some(vec!["test-cluster".to_string()]); // Optionally specify cluster names to describe
     let include = None; // Optionally specify fields to include in the description
 
     let result = describe_cluster(&client, clusters, include).await;
@@ -53,12 +53,11 @@ async fn test_describe_cluster() {
 }
 
 #[tokio::test]
-async fn test_show_clusters() {
-    // Replace with your AWS credentials and desired region
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_show_ecs_clusters() {
+    let client = create_client().await;
+
 
-    let max_results = Some(10); // Optionally specify max results to fetch
+    let max_results = Some(10);
 
     let result = show_clusters(&client, max_results).await;
     assert!(result.is_ok());
diff --git a/rustcloud/src/tests/eks_operations.rs b/rustcloud/src/tests/eks_operations.rs
index b7825a5..cd559f9 100644
--- a/rustcloud/src/tests/eks_operations.rs
+++ b/rustcloud/src/tests/eks_operations.rs
@@ -1,47 +1,48 @@
 use crate::aws::aws_apis::compute::aws_eks::*;
 use aws_sdk_eks::error::SdkError;
-use aws_sdk_eks::operation::create_cluster::CreateClusterError;
 use aws_sdk_eks::{Client, Config};
 use aws_sdk_eks::config::Region;
 use aws_sdk_eks::types::{VpcConfigRequest, KubernetesNetworkConfigRequest, NodegroupScalingConfig, AmiTypes, Logging, UpdateAccessConfigRequest};
 use std::collections::HashMap;
 
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
 #[tokio::test]
-async fn test_create_cluster() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_create_eks_cluster() {
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
-    let subnet_ids = vec!["subnet-12345678".to_string(), "subnet-87654321".to_string()];
     let version = Some("1.21".to_string());
-    let role_arn = Some("arn:aws:iam::123456789012:role/eks-role".to_string());
+    let role_arn = None;
     let resources_vpc_config = None;
     let kubernetes_network_config = None;
 
     let result = create_cluster(
         &client,
         cluster_name,
-        subnet_ids,
         version,
         role_arn,
         resources_vpc_config,
         kubernetes_network_config
-    );
+    ).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_create_node_group() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
     let nodegroup_name = "test-nodegroup".to_string();
     let scaling_config = Some(NodegroupScalingConfig::builder().desired_size(2).min_size(1).max_size(3).build());
-    let subnets = Some(vec!["subnet-12345678".to_string(), "subnet-87654321".to_string()]);
+    let subnets =None;
     let instance_types = Some(vec!["t3.medium".to_string()]);
     let ami_type = Some(AmiTypes::Al2X8664);
-    let node_role = Some("arn:aws:iam::123456789012:role/eks-node-role".to_string());
+    let node_role =None;
 
     let result = create_node_group(&client, cluster_name, nodegroup_name, None, scaling_config, subnets, instance_types, ami_type, None, node_role, None, None, None, None, None, None, None, None, None).await;
     assert!(result.is_ok());
@@ -49,8 +50,7 @@ async fn test_create_node_group() {
 
 #[tokio::test]
 async fn test_delete_nodegroup() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
     let nodegroup_name = "test-nodegroup".to_string();
@@ -60,9 +60,8 @@ async fn test_delete_nodegroup() {
 }
 
 #[tokio::test]
-async fn test_describe_cluster() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_describe_eks_cluster() {
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
 
@@ -72,8 +71,7 @@ async fn test_describe_cluster() {
 
 #[tokio::test]
 async fn test_describe_nodegroup() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
     let nodegroup_name = "test-nodegroup".to_string();
@@ -83,9 +81,8 @@ async fn test_describe_nodegroup() {
 }
 
 #[tokio::test]
-async fn test_delete_cluster() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_delete_eks_cluster() {
+    let client = create_client().await;
     
     let cluster_name = "test-cluster";
 
@@ -94,9 +91,8 @@ async fn test_delete_cluster() {
 }
 
 #[tokio::test]
-async fn test_list_clusters() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_list_eks_clusters() {
+    let client = create_client().await;
     
     let max_results = Some(10);
     let include = None;
@@ -107,8 +103,7 @@ async fn test_list_clusters() {
 
 #[tokio::test]
 async fn test_list_nodegroups() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
     let max_results = Some(10);
@@ -119,8 +114,7 @@ async fn test_list_nodegroups() {
 
 #[tokio::test]
 async fn test_update_tags() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let resource_arn = "arn:aws:eks:us-east-1:123456789012:cluster/test-cluster".to_string();
     let mut tags = HashMap::new();
@@ -132,8 +126,7 @@ async fn test_update_tags() {
 
 #[tokio::test]
 async fn test_update_config() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
     
     let cluster_name = "test-cluster".to_string();
     let resources_vpc_config = Some(VpcConfigRequest::builder().build());
diff --git a/rustcloud/src/tests/iam_operations.rs b/rustcloud/src/tests/iam_operations.rs
index 7d10c8a..da9f765 100644
--- a/rustcloud/src/tests/iam_operations.rs
+++ b/rustcloud/src/tests/iam_operations.rs
@@ -2,10 +2,17 @@ use crate::aws::aws_apis::security::aws_iam::*;
 use aws_sdk_iam::{Client, Config};
 use aws_sdk_iam::config::Region;
 
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
+
 #[tokio::test]
 async fn test_attach_group_policy() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let group_name = "TestGroup".to_string();
     let policy_arn = "arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess".to_string();
@@ -16,8 +23,7 @@ async fn test_attach_group_policy() {
 
 #[tokio::test]
 async fn test_create_group() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let path = "/".to_string();
     let group_name = "TestGroup".to_string();
@@ -28,8 +34,7 @@ async fn test_create_group() {
 
 #[tokio::test]
 async fn test_delete_group() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let group_name = "TestGroup".to_string();
 
@@ -39,8 +44,7 @@ async fn test_delete_group() {
 
 #[tokio::test]
 async fn test_detach_group_policy() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
     let group_name = "TestGroup".to_string();
     let policy_arn = "arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess".to_string();
@@ -50,13 +54,12 @@ async fn test_detach_group_policy() {
 }
 
 #[tokio::test]
-async fn test_describe() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_describe_group() {
+    let client = create_client().await;
 
     let group_name = "TestGroup".to_string();
-    let marker = "".to_string();
-    let max_items = 100;
+    let marker = None;
+    let max_items = Some(100);
 
     let result = describe(&client, group_name, marker, max_items).await;
     assert!(result.is_ok());
diff --git a/rustcloud/src/tests/kms_operations.rs b/rustcloud/src/tests/kms_operations.rs
index e0eeff1..b060c36 100644
--- a/rustcloud/src/tests/kms_operations.rs
+++ b/rustcloud/src/tests/kms_operations.rs
@@ -3,12 +3,19 @@ use aws_sdk_kms::{Client, Config};
 use aws_sdk_kms::config::Region;
 use aws_sdk_kms::types::{KeySpec, KeyUsageType, OriginType, Tag};
 
+
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
+}
+
 #[tokio::test]
 async fn test_create_key() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let policy = r#"{"Version": "2012-10-17","Statement": [{"Sid": "Enable IAM User Permissions","Effect": "Allow","Principal": {"AWS": "arn:aws:iam::111122223333:root"},"Action": "kms:*","Resource": "*"}]}"#.to_string();
+    let policy = r#"{"Version": "2012-10-17","Statement": [{"Sid": "Enable IAM User Permissions","Effect": "Allow","Principal": {"AWS": "arn:aws:iam::167355850481:user/rustcloud-testing-delete-asap"},"Action": "kms:*","Resource": "*"}]}"#.to_string();
     let description = Some("Test Key".to_string());
     let key_usage = Some(KeyUsageType::EncryptDecrypt);
     let key_spec = Some(KeySpec::SymmetricDefault);
@@ -20,8 +27,8 @@ async fn test_create_key() {
 
 #[tokio::test]
 async fn test_delete_key() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
+
 
     let custom_key_store_id = "cks-1234567890abcdef0".to_string();
 
@@ -31,10 +38,9 @@ async fn test_delete_key() {
 
 #[tokio::test]
 async fn test_describe_key() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let key_id = "1234abcd-12ab-34cd-56ef-1234567890ab".to_string();
+    let key_id = "07bfea74-a123-4760-8cb8-fa1a168983b8".to_string();
     let grant_tokens = None;
 
     let result = describe_key(&client, key_id, grant_tokens).await;
@@ -43,12 +49,11 @@ async fn test_describe_key() {
 
 #[tokio::test]
 async fn test_put_key_policy() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+    let client = create_client().await;
 
-    let key_id = "1234abcd-12ab-34cd-56ef-1234567890ab".to_string();
+    let key_id = "07bfea74-a123-4760-8cb8-fa1a168983b8".to_string();
     let policy_name = "default".to_string();
-    let policy = r#"{"Version": "2012-10-17","Statement": [{"Sid": "Enable IAM User Permissions","Effect": "Allow","Principal": {"AWS": "arn:aws:iam::111122223333:root"},"Action": "kms:*","Resource": "*"}]}"#.to_string();
+    let policy = r#"{"Version": "2012-10-17","Statement": [{"Sid": "Enable IAM User Permissions","Effect": "Allow","Principal": {"AWS": "arn:aws:iam::167355850481:user/rustcloud-testing-delete-asap"},"Action": "kms:*","Resource": "*"}]}"#.to_string();
     let bypass_policy_lockout_safety_check = None;
 
     let result = put_key_policy(&client, key_id, policy_name, policy, bypass_policy_lockout_safety_check).await;
@@ -56,11 +61,10 @@ async fn test_put_key_policy() {
 }
 
 #[tokio::test]
-async fn test_update() {
-    let config = Config::builder().region(Region::new("us-east-1")).build();
-    let client = Client::from_conf(config);
+async fn test_update_key() {
+    let client = create_client().await;
 
-    let key_id = "1234abcd-12ab-34cd-56ef-1234567890ab".to_string();
+    let key_id = "07bfea74-a123-4760-8cb8-fa1a168983b8".to_string();
     let description = Some("Updated Test Key".to_string());
 
     let result = update(&client, key_id, description).await;
diff --git a/rustcloud/src/tests/loadbalancer_operations.rs b/rustcloud/src/tests/loadbalancer_operations.rs
index 0336d83..f30eb96 100644
--- a/rustcloud/src/tests/loadbalancer_operations.rs
+++ b/rustcloud/src/tests/loadbalancer_operations.rs
@@ -4,17 +4,15 @@ use aws_sdk_elasticloadbalancing::types::{Tag};
 use aws_sdk_elasticloadbalancing::config::Region;
 
 
-fn create_client() -> Client {
-    // Replace with your actual AWS credentials and region for real scenarios
-    let config = Config::builder()
-        .region(Region::new("us-east-1")) // Specify your desired AWS region
-        .build();
-    Client::from_conf(config)
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
 }
 
 #[tokio::test]
-async fn test_add_tags() {
-    let client = create_client();
+async fn test_add_tags_to_loadbalancer() {
+    let client = create_client().await;
     let tag = Tag::builder().key("Environment".to_string()).value("Production".to_string()).build().unwrap();
     let result = add_tags(&client, "my-load-balancer".to_string(), tag ).await;
 
@@ -22,24 +20,24 @@ async fn test_add_tags() {
 }
 
 #[tokio::test]
-async fn test_create() {
-    let client = create_client();
+async fn test_create_loadbalancer() {
+    let client = create_client().await;
     let result = create(&client, "my-load-balancer".to_string(), None, None, None, None, None, None).await;
 
     assert!(result.is_ok());
 }
 
 #[tokio::test]
-async fn test_delete() {
-    let client = create_client();
+async fn test_delete_loadbalancer() {
+    let client = create_client().await;
     let result = delete(&client, "my-load-balancer".to_string()).await;
 
     assert!(result.is_ok());
 }
 
 #[tokio::test]
-async fn test_describe() {
-    let client = create_client();
+async fn test_describe_loadbalancer() {
+    let client = create_client().await;
     let result = describe(&client, "my-load-balancer".to_string()).await;
 
     assert!(result.is_ok());
@@ -47,7 +45,7 @@ async fn test_describe() {
 
 #[tokio::test]
 async fn test_list_load_balancers() {
-    let client = create_client();
+    let client = create_client().await;
     let result = list_load_balancers(&client, "my-load-balancer".to_string(), "marker".to_string(), 10).await;
 
     assert!(result.is_ok());
diff --git a/rustcloud/src/tests/mod.rs b/rustcloud/src/tests/mod.rs
index 031aebb..c4fd530 100644
--- a/rustcloud/src/tests/mod.rs
+++ b/rustcloud/src/tests/mod.rs
@@ -8,4 +8,5 @@ mod loadbalancer_operations;
 mod iam_operations;
 mod kms_operations;
 mod archival_operations;
-mod block_operations;
\ No newline at end of file
+mod block_operations;
+mod bucket_operations;
\ No newline at end of file
diff --git a/rustcloud/src/tests/monitoring_operations.rs b/rustcloud/src/tests/monitoring_operations.rs
index 285d9dd..dcacd48 100644
--- a/rustcloud/src/tests/monitoring_operations.rs
+++ b/rustcloud/src/tests/monitoring_operations.rs
@@ -5,15 +5,17 @@ use aws_sdk_cloudwatch::types::{ComparisonOperator, Statistic, MetricDataQuery,
 use aws_sdk_ec2::primitives::DateTime;
 use std::collections::HashMap;
 
-async fn get_client() -> Client {
-    let region_provider = RegionProviderChain::default_provider().or_else("us-east-1");
-    let config = aws_config::from_env().region(region_provider).load().await;
-    Client::new(&config)
+
+
+async fn create_client() -> Client {
+    let config =  aws_config::load_from_env().await;
+    let client =  Client::new(&config);
+    return client;
 }
 
 #[tokio::test]
 async fn test_delete_alarm() {
-    let client = get_client().await;
+    let client = create_client().await;
     let alarm_name = "test-alarm".to_string();
     let result = delete_alarm(&client, &alarm_name).await;
     assert!(result.is_ok());
@@ -21,7 +23,7 @@ async fn test_delete_alarm() {
 
 #[tokio::test]
 async fn test_get_metric_data() {
-    let client = get_client().await;
+    let client = create_client().await;
     
     let metric_data_queries = Some(vec![
         MetricDataQuery::builder()
@@ -63,18 +65,18 @@ async fn test_get_metric_data() {
 
 #[tokio::test]
 async fn test_list_alarms() {
-    let client = get_client().await;
+    let client = create_client().await;
     let result = list_alarms(&client).await;
     assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_put_metric_alarm() {
-    let client = get_client().await;
+    let client = create_client().await;
 
     let alarm_name = "test-alarm".to_string();
     let alarm_description = Some("This is a test alarm.".to_string());
-    let alarm_actions = Some(vec!["arn:aws:sns:us-east-1:123456789012:my-sns-topic".to_string()]);
+    let alarm_actions = None;
     let comparison_operator = Some(ComparisonOperator::GreaterThanThreshold);
     let evaluation_periods = Some(1);
     let metric_name = Some("CPUUtilization".to_string());