Initial Commit (not yet MVP 1.0)

source/introduction/bitrot-protection.rst

@@ -0,0 +1,18 @@
+.. _minio-bitrot-protection:
+
+=================
+Bitrot Protection
+=================
+
+Silent data corruption or bitrot is a serious problem faced by disk drives
+resulting in data getting corrupted without the user’s knowledge. The reasons
+are manifold (ageing drives, current spikes, bugs in disk firmware, phantom
+writes, misdirected reads/writes, driver errors, accidental overwrites) but the
+result is the same - compromised data.
+
+MinIO’s optimized implementation of the HighwayHash algorithm ensures that it
+will never read corrupted data - it captures and heals corrupted objects on the
+fly. Integrity is ensured from end to end by computing a hash on READ and
+verifying it on WRITE from the application, across the network and to the
+memory/drive. The implementation is designed for speed and can achieve hashing
+speeds over 10 GB/sec on a single core on Intel CPUs.

source/introduction/buckets.rst

@@ -0,0 +1,75 @@
+.. _minio-bucket:
+
+=======
+Buckets
+=======
+
+.. default-domain:: minio
+
+.. contents:: On This Page
+   :local:
+   :depth: 2
+
+
+A :ref:`bucket <minio-bucket>` is a folder or storage container that can hold an
+arbitrary number of :ref:`objects <minio-object>`. Minio buckets provide the
+same functionality as an Amazon Web Services (AWS) S3 Bucket. The MinIO API is
+fully compatible with the Amazon S3 API, where applications can seamlessly
+transition to using the MinIO deployment with minimal code changes.
+
+Bucket Notifications
+--------------------
+
+MinIO Bucket Notifications allow you to automatically publish notifications
+to one or more configured endpoints when specific events occur in a bucket.
+
+See :doc:`/minio-features/bucket-notifications` for more information.
+
+Push Notifications
+~~~~~~~~~~~~~~~~~~
+
+MinIO supports pushing events to the following targets:
+
+- AMQP
+- MQTT
+- Elasticsearch
+- NSQ
+- Redis
+- NATS
+- PostgreSQL
+- MySQL
+- Apache Kafka
+- Webhooks
+
+Use the ``mc admin`` utility to configure the MinIO deployment to actively
+push notifications to each configured target. For more complete documentation, 
+see <logging tbd>
+
+Listener API
+~~~~~~~~~~~~
+
+MinIO provides two routes to listen for events for a given bucket:
+
+- The ``mc event`` command.
+- The ``BucketNotification`` API.
+
+.. todo: Add more information here as its available. 
+
+Write Once Read Many (WORM)
+---------------------------
+
+MinIO supports enabling Write-Once Read-Many (WORM) for specific objects
+in a bucket *or* for all objects in the bucket. Objects with WORM applied
+are immutable, and can only be deleted if the WORM configuration includes an
+expiry. 
+
+Configure WORM for Bucket
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ToDo: Enable, Disable WORM
+
+Configure WORM for Specific Objects
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ToDo: Enable, Disable WORM per object
+

source/introduction/deployment-topologies.rst

@@ -0,0 +1,63 @@
+=====================
+Deployment Topologies
+=====================
+
+MinIO supports three deployment topologies:
+
+.. list-table::
+   :widths: 30 70
+   :header-rows: 1
+
+   * - Deployment Type
+     - Description
+
+   * - :ref:`Standalone <minio-deployment-standalone>`
+     - A single MinIO server.
+
+       Standalone deployments are ideal for local development and evaluation.
+
+   * - :ref:`Distributed <minio-deployment-distributed>`
+     - Multiple MinIO servers allow for horizontal scaling of storage while
+       allowing applications to treat the deployment as a single MinIO 
+       instance. 
+
+       Distributed deployments are ideal for production environments. 
+
+   * - :ref:`Active-Active <minio-deployment-active-active>`
+     - Multiple distributed deployments with intra-deployment
+       replication to synchronize :ref:`objects <minio-object>` across
+       deployments.
+
+       Active-Active Distributed deployments are ideal for production 
+       environments with globally distributed applications, where applications
+       prefer routing to the geographically-nearest MinIO instance. 
+
+.. _minio-deployment-standalone:
+
+Standalone Deployment
+---------------------
+
+TBD:
+- Add a diagram of a standalone deployment
+- List the drawbacks (if any)
+- Link to deployment tutorials (kubernetes, bare-metal)
+
+.. _minio-deployment-distributed:
+
+Distributed Deployment
+----------------------
+
+TBD:
+- Add a diagram of a distributed deployment
+- List the drawbacks (if any)
+- Link to deployment tutorials (kubernetes, bare-metal)
+
+.. _minio-deployment-active-active:
+
+Active-Active
+-------------
+
+TBD:
+- Add a diagram of a distributed deployment
+- List the drawbacks (if any)
+- Link to deployment tutorials (kubernetes, bare-metal)

source/introduction/erasure-coding.rst

@@ -0,0 +1,17 @@
+.. _minio-erasure-coding:
+
+==============
+Erasure Coding
+==============
+
+MinIO protects data with per-object, inline erasure coding, which is written in
+assembly code to deliver the highest performance possible. MinIO uses
+Reed-Solomon code to stripe objects into `n/2` data and ``n/2`` parity blocks -
+although these can be configured to any desired redundancy level.
+
+This means that in a 12 drive setup, an object is sharded across as 6 data and 6
+parity blocks. Even if you lose as many as 5 ((n/2)–1) drives, be it parity or
+data, you can still reconstruct the data reliably from the remaining drives.
+MinIO's implementation ensures that objects can be read or new objects are
+written even if multiple devices are lost or unavailable. Finally, MinIO's
+erasure code is at the object level and can heal one object at a time.

source/introduction/minio-overview.rst

@@ -0,0 +1,59 @@
+============
+Introduction
+============
+
+MinIO is a High Performance Object Storage released under Apache License v2.0.
+It is API compatible with Amazon S3 cloud storage service. Use MinIO to build
+high performance infrastructure for machine learning, analytics and application
+data workloads.
+
+What Is Object Storage?
+-----------------------
+
+Applications create, update, retrieve, and delete data as part of normal 
+operations. MinIO provides a complete solution for managing the storage 
+and access of that data as :ref:`objects <minio-object>`. Applications group
+objects into one or more :ref:`buckets <minio-bucket>`. 
+
+MinIO is fully compatible with the Amazon Web Services Simple Storage Service
+(AWS S3) API. Applications using the AWS S3 API can seamlessly transition to
+using a MinIO deployment for managing their application's object storage with
+minimal code changes. 
+
+Erasure Coding
+--------------
+
+MinIO Erasure Coding guarantees object retrieval as long as the deployment
+has at least half of its drives operational. Specifically, the deployment
+can lose `(n/2)-1` drives and still service create, retrieval, update, and 
+delete operations.
+
+For example, consider a deployment with 12 data drives. MinIO splits the
+12 drive set into 6 data drives and 6 parity drives. As long as *at least* 7
+drives are online, the MinIO server can guarantee retrieval of any stored
+object. 
+
+For more information on MinIO Erasure Coding, see
+:ref:`minio-erasure-coding`.
+
+Bitrot Protection
+-----------------
+
+MinIO Bitrot Protection heals objects that have degraded due to 
+disk corruption. When applications request a specific object, MinIO 
+automatically checks for corruption and applies a healing algorithm to 
+reconstruct the object. 
+
+For more information on MinIO Bitrot Protection, see 
+:ref:`minio-bitrot-protection`.
+
+
+.. toctree::
+   :hidden:
+   :titlesonly:
+
+   /introduction/buckets.rst
+   /introduction/objects.rst
+   /introduction/deployment-topologies.rst
+   /introduction/erasure-coding.rst
+   /introduction/bitrot-protection.rst

source/introduction/objects.rst

@@ -0,0 +1,15 @@
+.. _minio-object:
+
+=======
+Objects
+=======
+
+An :ref:`object <minio-object>` is any kind of data with no limit to its 
+size, format, or type. Examples of objects include digital images, 
+text documents, or video files. Applications can store, retrieve, and 
+delete objects from a MinIO deployment. 
+
+MinIO objects provide the same core functionality as an Amazon Web Services (AWS)
+S3 Object. The MinIO API is fully compatible with the Amazon S3 API, 
+where applications can seamlessly transition  to using the MinIO deployment
+with minimal code changes.