feat: s3 integration docs added

Author: HelloJowet

docs/data_engineering/data_lakehouse/delta_lake/rust/02_insert_data.md

@@ -15,17 +15,20 @@ async fn main() {
         Field::new("name", ArrowDataType::Utf8, true),
     ]));
 
-    // Create a employee record
+    // Create employee records
     let ids = Int32Array::from(vec![1, 2, 3]);
     let names = StringArray::from(vec!["Tom", "Tim", "Titus"]);
     let employee_record = RecordBatch::try_new(schema, vec![Arc::new(ids), Arc::new(names)]).unwrap();
 
-    // Insert record
+    // Insert records
     let table = DeltaOps(table).write(vec![employee_record]).await.expect("Insert failed");
 }
-
 ```
 
+> The Arrow Rust array primitives are _very_ fickle and so creating a direct transformation is quite tricky in Rust, whereas in Python or another loosely typed language it might be simpler.
+
+[(source)](https://github.com/delta-io/delta-rs/blob/99e39ca1ca372211cf7b90b62d33878fa961881c/crates/deltalake/examples/recordbatch-writer.rs#L156)
+
 ## Overwrite
 
 The default save mode for the `delta_ops.write` function is `SaveMode::Append`. To overwrite existing data instead of appending, use `SaveMode::Overwrite`:

docs/data_engineering/data_lakehouse/delta_lake/rust/integrations/object_storage/s3.md

@@ -0,0 +1,44 @@
+# S3 storage integration
+
+```rust
+use deltalake::{DeltaOps, DeltaTableBuilder, DeltaTableError};
+use std::env;
+
+fn configure_s3() {
+    // Set S3 configuration options using environment variables
+    env::set_var("AWS_ENDPOINT_URL", "http://localhost:5561");
+    env::set_var("AWS_REGION", "us-east-1");
+    env::set_var("AWS_ACCESS_KEY_ID", "admin");
+    env::set_var("AWS_SECRET_ACCESS_KEY", "password");
+    env::set_var("AWS_ALLOW_HTTP", "true");
+    env::set_var("AWS_S3_ALLOW_UNSAFE_RENAME", "true");
+
+    // Register AWS S3 handlers for Delta Lake operations
+    deltalake::aws::register_handlers(None);
+}
+
+/// Builds a `DeltaOps` instance for the specified Delta table.
+/// Enabling operations such as creating, reading and writing data in the Delta Lake format.
+async fn get_delta_ops(table_name: &str, load_state: bool) -> Result<DeltaOps, DeltaTableError> {
+    let delta_table_builder = DeltaTableBuilder::from_uri(format!("s3://data-lakehouse/{}", table_name));
+    let delta_table = match load_state {
+        // Load the existing table state
+        true => delta_table_builder.load().await?,
+        // Build the table without loading existing state
+        false => delta_table_builder.build()?,
+    };
+
+    Ok(DeltaOps::from(delta_table))
+}
+
+#[tokio::main()]
+async fn main() {
+    configure_s3();
+
+    let table_name = "employee";
+    let load_state = false;
+    let delta_ops = get_delta_ops(table_name, load_state).await.expect("Failed to create data_ops object");
+}
+```
+
+If the table doesn't exist yet, the `load_state` parameter in `get_delta_ops` should be set to `false`, as setting it to `true` would attempt to read a non-existent state, resulting in an error. On the other hand, if you want to read from an existing table, `load_state` must be set to `true` to successfully load the data; otherwise, the load operation will fail.