docs: review and standardize English documentation (#73)

Author: loverustfs

docs/about/index.md

@@ -36,7 +36,7 @@ Integrity, Focus, Simplicity
 
 ### Investor Relations
 
-For investment opportunities or strategic partnerships, please contact us.
+For investment opportunities or strategic partnerships, contact us.
 
 📧 **Contact**
 <hello@rustfs.com>

docs/administration/iam/index.md

@@ -3,10 +3,10 @@ title: "RustFS IAM Management"
 description: "Comprehensive guide to Identity and Access Management (IAM), including Users, Groups, Policies, and Access Keys."
 ---
 
-This chapter includes the following content:
+This section covers:
 
 - User Management
 - User Group Management
 - Policy Management
 - Bucket Policy
-- AK/SK
+- Access Keys (AK/SK)

docs/concepts/architecture.md

@@ -5,39 +5,36 @@ description: "Introduction to RustFS Architecture"
 
 # RustFS Architecture
 
-RustFS is an object storage system, similar to the well-known AWS S3. As a MinIO alternative, RustFS references MinIO's concise, lightweight, scalable, and elegant architecture.
+RustFS is a high-performance object storage system compatible with the AWS S3 API. It features a concise, lightweight, scalable, and decentralized architecture.
 
-Objects can be documents, videos, PDF files, etc. To store objects, MinIO provides a scalable, flexible, and efficient solution for storing, accessing, and managing data. Its compatibility with AWS S3 API enables seamless integration with AWS S3-based applications.
+Objects can be documents, videos, PDF files, or any other unstructured data. RustFS provides a scalable, flexible, and efficient solution for storing, accessing, and managing this data. Its compatibility with the AWS S3 API enables seamless integration with existing S3-based applications.
 
-The architecture diagram is as follows:
+The following diagram illustrates the architecture:
 
 ![RustFS Architecture Diagram](./images/s2-1.png)
 
-This is RustFS's basic architecture. A distributed grid is a computer architecture that uses multiple nodes to execute a single task. Nodes are connected to each other through a network, enabling them to communicate with each other.
+This diagram represents the basic architecture of RustFS. A distributed grid uses multiple nodes to execute a single task, connected via a network to enable communication.
 
 ## Consistency Design
 
-In both distributed and single-machine modes, all read and write operations strictly follow the read-after-write consistency model.
+In both distributed and single-machine modes, all read and write operations strictly follow the **read-after-write** consistency model.
 
-## Several Important Concepts in RustFS
+## Key Concepts
 
 **Object**: The fundamental unit of storage in RustFS, representing files, byte streams, or any unstructured data.
 
-**Bucket**: A logical container for storing Objects. Data is isolated between Buckets. For clients, it functions similarly to a top-level directory.
+**Bucket**: A logical container for storing objects. Data is isolated between buckets. For clients, it functions similarly to a top-level directory.
 
-**Drive**: The disk that stores data, passed as a parameter when RustFS starts. All object data in RustFS will be stored in Drives.
+**Drive**: The physical disk that stores data, passed as a parameter when RustFS starts. All object data in RustFS is stored on these drives.
 
-**Set**: A collection of a group of Drives. Distributed deployment automatically divides one or more Sets based on cluster scale. Drives in each Set are distributed in different locations. An object is stored on one Set. (Some places also call the combination of Sets **Strips** - stripes).
+**Set**: A group of drives. Distributed deployment automatically divides the cluster into one or more sets based on scale. Drives in each set are distributed across different locations. An object is stored within a single set. (Sometimes referred to as **Stripes**).
 
-Therefore, before designing the architecture and deploying devices, note that:
+Consider the following when designing the architecture and deploying devices:
 
-1. One object is stored on one Set;
-
-2. One cluster is divided into multiple Sets;
-
-3. The number of Drives contained in one Set is fixed, defaulting to automatic calculation by the system based on cluster scale;
-
-4. Drives in one Set should be distributed across different nodes as much as possible;
+- One object is stored on one set.
+- One cluster is divided into multiple sets.
+- The number of drives in a set is fixed, defaulting to automatic calculation by the system based on cluster scale.
+- Drives in a set should be distributed across different nodes as much as possible.
 
 ## Architectural Design
 

docs/concepts/introduction.md

@@ -1,6 +1,6 @@
 ---
 title: "What is RustFS?"
-description: "RustFS is an object storage solution - an open-source distributed object storage released under the Apache2 license."
+description: "RustFS is an open-source, distributed object storage solution released under the Apache 2.0 license."
 ---
 
 # What is RustFS?
@@ -13,14 +13,14 @@ RustFS is transitioning from commercial roots to a fully open-source model, aimi
 
 ## Operating System and CPU Support
 
-You can run RustFS on almost any CPU and operating system, whether it's Linux, Unix, Windows, MacOS, FreeBSD, Docker, or even edge gateways.
-CPU architecture support: X86, ARM, and various other CPU architectures.
+RustFS runs on almost any CPU and operating system, including Linux, Unix, Windows, macOS, FreeBSD, and Docker, as well as edge gateways.
+Supported CPU architectures: x86, ARM, and others.
 
 ## RustFS Features
 
 - **S3 Compatible**: Fully compatible with the S3 protocol, ensuring seamless integration with big data ecosystems, data lakes, backup solutions, and media processing workflows.
 - **Distributed Architecture**: Designed to scale horizontally to meet diverse storage requirements across various scales.
-- **Commercial-Friendly**: Released under the Apache v2.0 license, making it safe and flexible for commercial integration.
+- **Enterprise-Ready**: Released under the Apache v2.0 license, making it safe and flexible for commercial integration.
 - **High Performance**: Built with Rust, offering performance comparable to C/C++ but with modern safety guarantees.
 - **Secure by Design**: Leverages Rust's memory safety guarantees to significantly reduce common security vulnerabilities.
 - **Cross-Platform**: Runs natively on Windows, macOS, and Linux.

docs/developer/index.md

@@ -1,9 +1,9 @@
 ---
 title: RustFS Developer Guide
-description: Introduction to using STS/MCP/MinIO Client/SDK/API in RustFS, helping developers use RustFS more efficiently.
+description: Guide to using STS, MCP, MinIO Client, SDKs, and APIs with RustFS.
 ---
 
-This guide provides comprehensive instructions for integrating and interacting with RustFS using STS, MCP (Model Context Protocol), MinIO Client (`mc`), SDKs, and APIs. It is designed to enable developers to build efficient and scalable applications on top of RustFS. This document covers the following topics:
+This guide provides instructions for integrating and interacting with RustFS using STS, MCP (Model Context Protocol), MinIO Client (`mc`), SDKs, and APIs. It is designed to enable developers to build efficient and scalable applications on top of RustFS. This document covers the following topics:
 
 - STS
 - [MCP Usage Guide](./mcp.md)

docs/developer/license.md

@@ -1,14 +1,14 @@
 ---
 title: RustFS Open Source License
-description: RustFS is released under the 100% commercial-friendly Apache v2.0 license
+description: RustFS is released under the Apache 2.0 license.
 ---
 
 # RustFS Open Source License
 
 ## Open Source License
 
-- RustFS is released under the 100% commercial-friendly Apache v2.0 license
-- [Apache v2.0](https://www.apache.org/licenses/LICENSE-2.0)
+- RustFS is released under the Apache 2.0 license.
+- [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
 ## License Terms
 

docs/developer/mc.md

@@ -1,21 +1,21 @@
 ---
-title: "Managing RustFS Objects with MinIO Client"
-description: "Managing RustFS objects with MinIO Client"
+title: "Manage RustFS Objects with MinIO Client"
+description: "Manage RustFS objects using the MinIO Client."
 ---
 
 # MinIO Client (`mc`)
 
-MinIO Client (`mc`) is an official command-line tool provided by MinIO for managing MinIO object storage services. `mc` can interact with MinIO, Amazon S3, and other S3-compatible object storage services, providing a simple and efficient way to manage data in object storage services. Since MinIO is S3-compatible, `mc` can also be used to manage RustFS objects.
+The MinIO Client (`mc`) is a command-line tool for managing object storage services. It supports MinIO, Amazon S3, and other S3-compatible services. As RustFS is S3-compatible, you can use `mc` to manage RustFS objects.
 
 Prerequisites:
 
-- An available RustFS instance. Refer to the [Installation Guide](../installation/index.md) for installation.
-- `mc` tool is installed.
+- An available RustFS instance. Refer to the [Installation Guide](../installation/index.md).
+- The `mc` tool is installed.
 - Available [access keys](../administration/iam/access-token.md).
 
-## Using `mc` to Operate RustFS
+## Using `mc` with RustFS
 
-First, you need to use the `mc alias` command to configure an alias for RustFS:
+First, configure an alias for RustFS using the `mc alias` command:
 
 ```bash
 mc alias set rustfs http://12.34.56.78:9000 ACCESS_KEY SECRET_KEY
@@ -27,11 +27,11 @@ Output:
 Added `rustfs` successfully.
 ```
 
-Next, you can use `mc` to operate on the alias `rustfs` to create/delete buckets, upload/download files, etc.
+You can now use `mc` with the `rustfs` alias to create/delete buckets, upload/download files, etc.
 
 ### List Buckets
 
-Use `mc ls` to list all buckets under the current RustFS instance:
+List all buckets:
 
 ```bash
 mc ls rustfs
@@ -47,7 +47,7 @@ Output:
 
 ### Create Bucket
 
-Use `mc mb` command to create a bucket:
+Create a bucket:
 
 ```bash
 mc mb rustfs/bucket-creation-by-mc
@@ -61,7 +61,7 @@ Bucket created successfully `rustfs/bucket-creation-by-mc`.
 
 ### Delete Bucket
 
-Use `mc rb` command to delete a bucket:
+Delete a bucket:
 
 ```bash
 mc rb rustfs/bucket-creation-by-mc
@@ -73,9 +73,9 @@ Output:
 Removed `rustfs/bucket-creation-by-mc` successfully.
 ```
 
-### Upload File to Bucket
+### Upload File
 
-Use `mc cp` command to upload a file to a bucket:
+Upload a file to a bucket:
 
 ```bash
 mc cp file_name rustfs/bucket-creation-by-mc
@@ -87,9 +87,9 @@ Output:
 ...path/to/file_name: 4 B / 4 B  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  12 B/s 0s%
 ```
 
-### Delete File in Bucket
+### Delete File
 
-Use `mc rm` command to delete a file in a bucket:
+Delete a file from a bucket:
 
 ```bash
 mc rm rustfs/bucket-creation-by-mc/file_name

docs/developer/mcp.md

@@ -5,7 +5,7 @@ description: "RustFS MCP Usage Guide"
 
 # RustFS MCP
 
-**RustFS MCP Server** is a high-performance [Model Context Protocol (MCP)](https://www.anthropic.com/news/model-context-protocol) server that provides AI/LLM tools with seamless access to S3-compatible object storage operations. Built with Rust for maximum performance and security, it enables AI assistants like Claude Desktop to interact with cloud storage through standardized protocols.
+**RustFS MCP Server** is a high-performance [Model Context Protocol (MCP)](https://www.anthropic.com/news/model-context-protocol) server that provides AI/LLM tools with seamless access to S3-compatible object storage operations. Built with Rust for performance and security, it enables AI assistants like Claude Desktop to interact with cloud storage through standardized protocols.
 
 ### What is MCP?
 
@@ -15,16 +15,16 @@ The Model Context Protocol is an open standard that enables AI applications to e
 
 ### Supported S3 Operations
 
-- **List Buckets**: List all accessible S3 buckets
-- **List Objects**: Browse bucket contents with optional prefix filtering
-- **Upload Files**: Upload local files with automatic MIME type detection and cache control
-- **Get Objects**: Retrieve objects from S3 storage, supporting read or download modes
+- **List Buckets**: Lists all accessible S3 buckets.
+- **List Objects**: Browses bucket contents with optional prefix filtering.
+- **Upload Files**: Uploads local files with automatic MIME type detection and cache control.
+- **Get Objects**: Retrieves objects from S3 storage, supporting read or download modes.
 
 ## 🔧 Installation
 
 ### Prerequisites
 
-- Rust 1.88+ (for building from source)
+- Rust 1.75+ (for building from source)
 - Configured AWS credentials (via environment variables, AWS CLI, or IAM roles)
 - Access to S3-compatible storage services
 

docs/developer/sdk/go.md

@@ -1,22 +1,22 @@
 ---
-title: "RustFS Golang SDK Usage Guide"
+title: "Golang SDK Guide"
 description: "Use the Golang SDK to operate on RustFS instances, including creating and deleting buckets and objects."
 ---
 
 # Golang SDK
 
-Since RustFS is a fully S3-compatible object storage system, you can build a Golang SDK suitable for RustFS by wrapping the S3 Golang SDK. Through the SDK, you can operate on RustFS, including creating and deleting buckets/objects, uploading and downloading files, etc.
+RustFS is fully S3-compatible. You can use the standard AWS SDK for Go to interact with RustFS. Through the SDK, you can operate on RustFS, including creating and deleting buckets/objects, uploading and downloading files, etc.
 
 ## Prerequisites
 
-- A working RustFS instance (refer to [Installation Guide](../../installation/index.md) for installation).
-- Access keys (refer to [Access Key Management](../../administration/iam/access-token.md) for creation).
+- A working RustFS instance (refer to [Installation Guide](../../installation/index.md)).
+- Access keys (refer to [Access Key Management](../../administration/iam/access-token.md)).
 
-## RustFS Golang SDK Construction
+## Initializing the Client
 
-Use `RUSTFS_ACCESS_KEY_ID`, `RUSTFS_SECRET_ACCESS_KEY`, `RUSTFS_ENDPOINT_URL`, `RUSTFS_REGION` to construct an `aws.Config`, then use `s3.NewFromConfig` from the Golang S3 SDK to build a RustFS Client:
+Configure `aws.Config` using environment variables and initialize the client:
 
-```
+```go
 region := os.Getenv("RUSTFS_REGION")
 access_key_id := os.Getenv("RUSTFS_ACCESS_KEY_ID")
 secret_access_key := os.Getenv("RUSTFS_SECRET_ACCESS_KEY")
@@ -44,7 +44,7 @@ client := s3.NewFromConfig(cfg, func(o *s3.Options) {
 })
 ```
 
-Then you can use the constructed RustFS Client to perform bucket and object operations.
+You can now perform bucket and object operations.
 
 ## Create Bucket
 

docs/developer/sdk/index.md

@@ -1,15 +1,15 @@
 ---
 title: "RustFS SDK Overview"
-description: "Which S3 SDKs can be used with RustFS? This article provides a detailed explanation."
+description: "Overview of supported S3 SDKs for RustFS."
 ---
 
 # SDK Overview
 
-RustFS is a distributed object storage software that is 100% compatible with the S3 protocol. Users can:
+RustFS is a distributed object storage system fully compatible with the S3 protocol. Users can:
 
-1. Manage RustFS through the Console management interface;
-2. Manage RustFS through S3 clients;
-3. Implement object storage operations and management on the business side through SDKs.
+- Manage RustFS through the Console management interface.
+- Manage RustFS through S3 clients.
+- Implement object storage operations and management on the business side through SDKs.
 
 Currently, the SDKs provided by RustFS include:
 
@@ -20,27 +20,26 @@ Currently, the SDKs provided by RustFS include:
 - [TypeScript SDK](./typescript.md)
 - [Golang SDK](./go.md)
 
-## Terminology Explanation Before Reading
+## Terminology
 
-S3 is the name of the first object storage product opened and launched by Amazon. It opened all its protocols and specifications. Later, almost all object storage systems followed the S3 protocols and specifications. Sometimes people call S3 object storage, and sometimes they simply call S3 the object storage protocol.
+Amazon S3 (Simple Storage Service) was the first widely adopted object storage service. Its API has become the de facto standard for object storage. In this documentation, "S3" refers to the protocol.
 
 ## 1. SDK Recommendations
 
-Since there are already too many SDKs on the market that have been maintained for many years, such as AWS S3 SDK which has been debugged and optimized for many years. Its performance and errors are almost zero. Therefore, we recommend that you directly use the standard AWS S3 SDK to directly control and communicate with RustFS.
+We recommend using the official AWS S3 SDKs. These SDKs are mature, well-maintained, and highly optimized.
 
 If you have a familiar and trusted SDK from a vendor, you can use it.
 
-Because many Chinese cloud providers have made "modifications" in many places and do not support many of the latest S3 technologies, many object storage products around the world do not recommend the SDKs of many Chinese cloud providers.
+Some third-party SDKs may have non-standard implementations. We recommend avoiding SDKs that are not strictly S3-compliant.
 
-## 2. Can MinIO SDKs communicate directly with RustFS?
+## 2. Compatibility with MinIO SDKs
 
-Yes.
-
-We have conducted comprehensive adaptation and compatibility for MinIO SDKs.
+Yes, RustFS is fully compatible with MinIO SDKs.
 
 If you are using MinIO SDKs, you can modify the Endpoint, AK, and SK to be directly compatible with RustFS.
 
-## 3. What to do if there are other incompatible SDKs?
+## 3. Handling Incompatible SDKs
+
+If you encounter an SDK that does not support standard S3, MinIO, or RustFS:
 
-If we use an SDK from a cloud provider that does not support the latest S3, MinIO, or RustFS, how should we handle it?
-Please replace the SDK as soon as possible and re-match and upgrade on the business side.
+We recommend switching to a standard AWS S3 SDK.