minio/docs
1
0
Fork 0
mirror of https://github.com/minio/docs.git synced 2025-07-30 07:03:26 +03:00
Code Activity

Docs Multiplatform Slice

Browse Source
This commit is contained in:
Ravind Kumar
2022-05-06 16:44:42 -04:00
parent df33ddee6a
commit b99c20a16f
134 changed files with 3689 additions and 2200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
source/includes/common-installation.rst
View File

@ -1,105 +1,3 @@
.. start-install-minio-binary-desc
The following tabs provide examples of installing MinIO onto 64-bit Linux
operating systems using RPM, DEB, or binary. The RPM and DEB packages
automatically install MinIO to the necessary system paths and create a
``systemd`` service file for running MinIO automatically. MinIO strongly
recommends using RPM or DEB installation routes.
.. tab-set::
.. tab-item:: RPM (RHEL)
:sync: rpm
Use the following commands to download the latest stable MinIO RPM and
install it.
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-rpm| -O minio.rpm
sudo dnf install minio.rpm
.. tab-item:: DEB (Debian/Ubuntu)
:sync: deb
Use the following commands to download the latest stable MinIO DEB and
install it:
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-deb| -O minio.deb
sudo dpkg -i minio.deb
.. tab-item:: Binary
:sync: binary
Use the following commands to download the latest stable MinIO binary and
install it to the system ``$PATH``:
.. code-block:: shell
:class: copyable
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
.. end-install-minio-binary-desc
.. start-upgrade-minio-binary-desc
The following tabs provide examples of updating MinIO onto 64-bit Linux
operating systems using RPM, DEB, or binary:
.. tab-set::
.. tab-item:: RPM (RHEL)
:sync: rpm
Use the following commands to download the latest stable MinIO RPM and
update the existing installation.
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-rpm| -O minio.deb
sudo dnf update minio.rpm
.. tab-item:: DEB (Debian/Ubuntu)
:sync: deb
Use the following commands to download the latest stable MinIO DEB and
upgrade the existing installation:
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-deb| -O minio.deb
sudo dpkg -i minio.deb
.. tab-item:: Binary
:sync: binary
Use the following commands to download the latest stable MinIO binary and
overwrite the existing binary:
.. code-block:: shell
:class: copyable
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
Replace ``/usr/local/bin`` with the location of the existing MinIO
binary. Run ``which minio`` to identify the path if not already known.
.. end-upgrade-minio-binary-desc
.. start-install-minio-tls-desc
MinIO enables :ref:`Transport Layer Security (TLS) <minio-tls>` 1.2+
@ -134,118 +32,6 @@ recommends *against* non-TLS deployments outside of early development.
.. end-install-minio-tls-desc
.. start-install-minio-systemd-desc
The ``.deb`` or ``.rpm`` packages install the following
`systemd <https://www.freedesktop.org/wiki/Software/systemd/>`__ service file to
``/etc/systemd/system/minio.service``. For binary installations, create this
file manually on all MinIO hosts:
.. code-block:: shell
:class: copyable
[Unit]
Description=MinIO
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio
[Service]
WorkingDirectory=/usr/local
User=minio-user
Group=minio-user
ProtectProc=invisible
EnvironmentFile=-/etc/default/minio
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_VOLUMES}\" ]; then echo \"Variable MINIO_VOLUMES not set in /etc/default/minio\"; exit 1; fi"
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
# Let systemd restart this service always
Restart=always
# Specifies the maximum file descriptor number that can be opened by this process
LimitNOFILE=65536
# Specifies the maximum number of threads this process can create
TasksMax=infinity
# Disable timeout logic and wait until process is stopped
TimeoutStopSec=infinity
SendSIGKILL=no
[Install]
WantedBy=multi-user.target
# Built for ${project.name}-${project.version} (${project.name})
The ``minio.service`` file runs as the ``minio-user`` User and Group by default.
You can create the user and group using the ``groupadd`` and ``useradd``
commands. The following example creates the user, group, and sets permissions
to access the folder paths intended for use by MinIO. These commands typically
require root (``sudo``) permissions.
.. code-block:: shell
:class: copyable
groupadd -r minio-user
useradd -M -r -g minio-user minio-user
chown minio-user:minio-user /mnt/disk1 /mnt/disk2 /mnt/disk3 /mnt/disk4
The specified disk paths are provided as an example. Change them to match
the path to those disks intended for use by MinIO.
Alternatively, change the ``User`` and ``Group`` values to another user and
group on the system host with the necessary access and permissions.
MinIO publishes additional startup script examples on
:minio-git:`github.com/minio/minio-service <minio-service>`.
.. end-install-minio-systemd-desc
.. start-install-minio-start-service-desc
.. code-block:: shell
:class: copyable
sudo systemctl start minio.service
Use the following commands to confirm the service is online and functional:
.. code-block:: shell
:class: copyable
sudo systemctl status minio.service
journalctl -f -u minio.service
MinIO may log an increased number of non-critical warnings while the
server processes connect and synchronize. These warnings are typically
transient and should resolve as the deployment comes online.
.. end-install-minio-start-service-desc
.. start-install-minio-restart-service-desc
.. code-block:: shell
:class: copyable
sudo systemctl restart minio.service
Use the following commands to confirm the service is online and functional:
.. code-block:: shell
:class: copyable
sudo systemctl status minio.service
journalctl -f -u minio.service
MinIO may log an increased number of non-critical warnings while the
server processes connect and synchronize. These warnings are typically
transient and should resolve as the deployment comes online.
.. end-install-minio-restart-service-desc
.. start-install-minio-console-desc
Open your browser and access any of the MinIO hostnames at port ``:9001`` to
@ -267,6 +53,53 @@ Console.
.. end-install-minio-console-desc
.. start-local-jbod-single-node-desc
MinIO strongly recommends direct-attached :abbr:`JBOD (Just a Bunch of Disks)`
arrays with XFS-formatted disks for best performance.
- Direct-Attached Storage (DAS) has significant performance and consistency
advantages over networked storage (NAS, SAN, NFS).
- Deployments using non-XFS filesystems (ext4, btrfs, zfs) tend to have
lower performance while exhibiting unexpected or undesired behavior.
- RAID or similar technologies do not provide additional resilience or
availability benefits when used with distributed MinIO deployments, and
typically reduce system performance.
Ensure all server drives for which you intend MinIO to use are of the same type (NVMe, SSD, or HDD) with identical capacity (e.g. ``12`` TB).
MinIO does not distinguish drive types and does not benefit from mixed storage types.
Additionally. MinIO limits the size used per disk to the smallest drive in the deployment.
For example, if the deployment has 15 10TB disks and 1 1TB disk, MinIO limits the per-disk capacity to 1TB.
MinIO *requires* using expansion notation ``{x...y}`` to denote a sequential series of disks when creating the new |deployment|, where all nodes in the |deployment| have an identical set of mounted drives.
MinIO also requires that the ordering of physical disks remain constant across restarts, such that a given mount point always points to the same formatted disk.
MinIO therefore **strongly recommends** using ``/etc/fstab`` or a similar file-based mount configuration to ensure that drive ordering cannot change after a reboot.
For example:
.. code-block:: shell
$ mkfs.xfs /dev/sdb -L DISK1
$ mkfs.xfs /dev/sdc -L DISK2
$ mkfs.xfs /dev/sdd -L DISK3
$ mkfs.xfs /dev/sde -L DISK4
$ nano /etc/fstab
# <file system> <mount point> <type> <options> <dump> <pass>
LABEL=DISK1 /mnt/disk1 xfs defaults,noatime 0 2
LABEL=DISK2 /mnt/disk2 xfs defaults,noatime 0 2
LABEL=DISK3 /mnt/disk3 xfs defaults,noatime 0 2
LABEL=DISK4 /mnt/disk4 xfs defaults,noatime 0 2
You can then specify the entire range of disks using the expansion notation ``/mnt/disk{1...4}``.
If you want to use a specific subfolder on each disk, specify it as ``/mnt/disk{1...4}/minio``.
MinIO **does not** support arbitrary migration of a drive with existing MinIO data to a new mount position, whether intentional or as the result of OS-level behavior.
.. end-local-jbod-single-node-desc
.. start-local-jbod-desc
MinIO strongly recommends direct-attached :abbr:`JBOD (Just a Bunch of Disks)`

147
source/includes/common/installation.rst Normal file
View File

@ -0,0 +1,147 @@
.. _minio-installation:
========================
Install and Deploy MinIO
========================
.. default-domain:: minio
.. contents:: Table of Contents
:local:
:depth: 1
MinIO is a software-defined high performance distributed object storage server.
You can run MinIO on consumer or enterprise-grade hardware and a variety
of operating systems and architectures.
MinIO supports three deployment modes:
Standalone Single-Drive
A single MinIO server with a single storage volume or folder, also referred to as "Filesystem Mode".
Standalone single deployments are best suited for evaluation and initial development of applications using MinIO for object storage, *or* for providing an S3 access layer to single storage volume.
Standalone deployments do not provide access to the full set of MinIO's advanced S3 features and functionality - specifically those dependent on :ref:`Erasure Coding <minio-erasure-coding>`.
Standalone Multi-Drive
A single MinIO server with *at least* four storage volumes or folders.
A standalone multi-drive deployment supports and enables :ref:`erasure coding <minio-erasure-coding>` and its dependent features.
Standalone multi-drive deployments can only provide drive-level availability and performance scaling.
Use standalone multi-drive deployments for small-scale environments which do not require high availability or scalable performance characteristics.
Distributed Deployments
One or more MinIO servers with *at least* four total storage volumes across all servers.
A distributed deployment supports and enables :ref:`erasure coding <minio-erasure-coding>` and its dependent features.
Distributed deployments provide drive and server-level availability and performance scaling.
Distributed deployments are best for production environments and workloads.
MinIO recommends a baseline topology of 4 nodes with 4 drives each for production environments.
This topology provides continuity with the loss of up to one server *or* four drives across all servers.
.. _minio-installation-comparison:
The following table compares the key functional differences between MinIO deployments:
.. list-table::
:header-rows: 1
:width: 100%
* -
- :guilabel:`Standalone Single-Drive`
- :guilabel:`Standalone Multi-Drive`
- :guilabel:`Distributed`
* - Site-to-Site Replication
- Client-Side via :mc:`mc mirror`
- :ref:`Server-Side Replication <minio-bucket-replication>`
- :ref:`Server-Side Replication <minio-bucket-replication>`
* - Versioning
- No
- :ref:`Object Versioning <minio-bucket-versioning>`
- :ref:`Object Versioning <minio-bucket-versioning>`
* - Retention
- No
- :ref:`Write-Once Read-Many Locking <minio-bucket-locking>`
- :ref:`Write-Once Read-Many Locking <minio-bucket-locking>`
* - High Availability / Redundancy
- Drive Level Only (RAID and similar)
- Drive Level only with :ref:`Erasure Coding <minio-erasure-coding>`
- Drive and Server-Level with :ref:`Erasure Coding <minio-erasure-coding>`
* - Scaling
- No
- :ref:`Server Pool Expansion <expand-minio-distributed>`
- :ref:`Server Pool Expansion <expand-minio-distributed>`.
Site Replication
----------------
Site replication expands the features of bucket replication to include IAM, security tokens, service accounts, and bucket features the same across all sites.
:ref:`Site replication <minio-site-replication-overview>` links multiple MinIO deployments together and keeps the buckets, objects, and Identify and Access Management (IAM) settings in sync across all connected sites.
.. include:: /includes/common-replication.rst
:start-after: start-mc-admin-replicate-what-replicates
:end-before: end-mc-admin-replicate-what-replicates
What Does Not Replicate?
~~~~~~~~~~~~~~~~~~~~~~~~
Not everything replicates across sites.
.. include:: /includes/common-replication.rst
:start-after: start-mc-admin-replicate-what-does-not-replicate
:end-before: end-mc-admin-replicate-what-does-not-replicate
.. _minio-installation-platform-support:
Platform Support
----------------
MinIO provides builds of the MinIO server (:mc:`minio`) and the
MinIO :abbr:`CLI (Command Line Interface)` (:mc:`mc`) for the following
platforms.
.. cond:: linux
- Red Hat Enterprise Linux 8.5+ (including all binary-compatible RHEL alternatives)
- Ubuntu 18.04+
MinIO provides builds for the following architectures:
- AMD64
- ARM64
- PowerPC 64 LE
- S390X
.. cond:: macos
MinIO recommends non-EOL macOS versions (10.14+).
.. cond:: windows
MinIO recommends non-EOL Windows versions (Windows 10, Windows Server 2016+).
Support for running :ref:`distributed MinIO deployments <deploy-minio-distributed>` is *experimental* on Windows OS.
For unlisted platforms or architectures, please reach out to MinIO at
hello@min.io for additional support and guidance. You can build MinIO from
:minio-git:`source <minio/#install-from-source>` and
`cross-compile
<https://golang.org/doc/install/source#bootstrapFromCrosscompiledSource>`__
for your platform and architecture combo. MinIO generally does not recommend
source-based installations in production environments.
.. toctree::
:titlesonly:
:hidden:
/operations/install-deploy-manage/deploy-minio-single-node-single-drive
/operations/install-deploy-manage/deploy-minio-single-node-multi-drive
/operations/install-deploy-manage/deploy-minio-multi-node-multi-drive
/operations/install-deploy-manage/multi-site-replication

371
source/includes/containers/quickstart.rst Normal file
View File

@ -0,0 +1,371 @@
.. _quickstart-container:
=========================
Quickstart for Containers
=========================
.. default-domain:: minio
.. |OS| replace:: Docker or Podman
This procedure deploys a :ref:`Single-Node Single-Drive <minio-installation-comparison>` MinIO server onto |OS| for early development and evaluation of MinIO Object Storage and its S3-compatible API layer.
For instructions on deploying to production environments, see :ref:`deploy-minio-distributed`.
Prerequisites
-------------
- `Podman <https://podman.io/getting-started/installation.html>`_ or `Docker <https://docs.docker.com/get-docker/>`_ installed.
- Read, write, and delete access to the folder or drive used for the persistent volume.
Procedure
---------
#. Start the container
Select a container type to view instructions to create the container.
Instructions are available for either GNU/Linux and MacOS or for Windows.
.. dropdown:: Podman (Rootfull or Rootless)
:name: podman-root-rootless
These steps work for both rootfull and rootless containers.
.. tab-set::
.. tab-item:: GNU/Linux or MacOS
.. code-block:: shell
:class: copyable
podman run \
-p 9000:9000 \
-p 9090:9090 \
-v ~/minio/data:/data \
-e "MINIO_ROOT_USER=ROOTNAME" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``podman run`` starts the container.
The process is attached to the terminal session and ends when exiting the terminal.
- ``-p`` binds a local port to a container port.
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data mirrors to the local path ``~/minio/data``, allowing it to persist between container restarts.
You can set any file path to which the user has read, write, and delete permissions to use.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
.. tab-item:: Windows
.. code-block:: shell
:class: copyable
podman run \
-p 9000:9000 \
-p 9090:9090 \
-v D:\data:/data \
-e "MINIO_ROOT_USER=ROOTNAME" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``podman run`` starts the container.
- ``-p`` binds a local port to a container port.
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data mirrors to the local path ``D:\data``, allowing it to persist between container restarts.
You can set any file path to which the user has read, write, and delete permissions to use.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
.. dropdown:: Docker (Rootfull)
:name: docker-rootfull
.. tab-set::
.. tab-item:: GNU/Linux or MacOS
.. code-block:: shell
:class: copyable
mkdir -p ~/minio/data
docker run \
-p 9000:9000 \
-p 9090:9090 \
--name minio \
-v ~/minio/data:/data \
-e "MINIO_ROOT_USER=ROOTNAME" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``mkdir`` creates a new local directory at ``~/minio/data`` in your home directory.
- ``docker run`` starts the MinIO container.
- ``-p`` binds a local port to a container port.
- ``-name`` creates a name for the container.
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data mirrors to the local path ``~/minio/data``, allowing it to persist between container restarts.
You can replace ``~/minio/data`` with another local file location to which the user has read, write, and delete access.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
.. tab-item:: Windows
.. code-block:: shell
:class: copyable
docker run \
-p 9000:9000 \
-p 9090:9090 \
--name minio1 \
-v D:\data:/data \
-e "MINIO_ROOT_USER=ROOTUSER" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``docker run`` starts the MinIO container.
- ``-p`` binds a local port to a container port.
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data mirrors to the local path ``D:\data``, allowing it to persist between container restarts.
You can replace ``D:\data`` with another local file location to which the user has read, write, and delete access.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
.. dropdown:: Docker (Rootless)
:name: docker-rootless
.. tab-set::
.. tab-item:: GNU/Linux or MacOS
.. code-block:: shell
:class: copyable
mkdir -p ${HOME}/data
docker run \
-p 9000:9000 \
-p 9090:9090 \
--user $(id -u):$(id -g) \
--name minio1 \
-e "MINIO_ROOT_USER=ROOTUSER" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
-v ${HOME}/minio/data:/data \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``mkdir`` creates a new local directory at ``~/minio/data`` in your home directory.
- ``docker run`` starts the MinIO container.
- ``-p`` binds a local port to a container port.
- ``-user`` sets the username for the container to the policies for the current user and user group.
- ``-name`` creates a name for the container.
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data actually writes to the local path ``~/minio/data`` where it can persist between container restarts.
You can replace ``${HOME}/minio/data`` with another location in the user's home directory to which the user has read, write, and delete access.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
.. tab-item:: Windows
Prerequisite:
- Windows `Group Managed Service Account <https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts>`_ already defined.
.. code-block:: shell
:class: copyable
docker run \
-p 9000:9000 \
-p 9090:9090 \
--name minio1 \
--security-opt "credentialspec=file://path/to/file.json"
-e "MINIO_ROOT_USER=ROOTUSER" \
-e "MINIO_ROOT_PASSWORD=CHANGEME123" \
-v D:\data:/data \
quay.io/minio/minio server /data --console-address ":9090"
The example above works this way:
- ``docker run`` starts the MinIO container.
- ``-p`` binds a local port to a container port.
- ``-name`` creates a name for the container.
- ``--security-opt`` grants access to the container via a ``credentialspec`` file for a `Group Managed Service Account (gMSA) <https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-run-container>`_
- ``-v`` sets a file path as a persistent volume location for the container to use.
When MinIO writes data to ``/data``, that data actually writes to the local path ``D:\data`` where it can persist between container restarts.
You can replace ``D:\data`` with another local file location to which the user has read, write, and delete access.
- ``-e`` sets the environment variables :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD`, respectively.
These set the :ref:`root user credentials <minio-users-root>`.
Change the example values to use for your container.
#. Connect your Browser to the MinIO Server
Access the :ref:`minio-console` by going to a browser and going to ``http://127.0.0.1:9000`` or one of the Console addresses specified in the :mc:`minio server` command's output.
For example, :guilabel:`Console: http://192.0.2.10:9090 http://127.0.0.1:9090` in the example output indicates two possible addresses to use for connecting to the Console.
While port ``9000`` is used for connecting to the API, MinIO automatically redirects browser access to the MinIO Console.
Log in to the Console with the credentials you defined in the :envvar:`MINIO_ROOT_USER` and :envvar:`MINIO_ROOT_PASSWORD` environment variables.
.. image:: /images/minio-console/console-login.png
:width: 600px
:alt: MinIO Console displaying login screen
:align: center
You can use the MinIO Console for general administration tasks like Identity and Access Management, Metrics and Log Monitoring, or Server Configuration.
Each MinIO server includes its own embedded MinIO Console.
.. image:: /images/minio-console/minio-console.png
:width: 600px
:alt: MinIO Console displaying bucket start screen
:align: center
For more information, see the :ref:`minio-console` documentation.
#. `(Optional)` Install the MinIO Client
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO volume from the commandline.
Select your operating system for instructions.
.. dropdown:: GNU/Linux
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO server from the commandline.
Download the :mc:`mc` client and install it to a location on your system ``PATH`` such as
``/usr/local/bin``. You can alternatively run the binary from the download location.
.. code-block:: shell
:class: copyable
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
Use :mc-cmd:`mc alias set` to create a new alias associated to your local deployment.
You can run :mc-cmd:`mc` commands against this alias:
.. code-block:: shell
:class: copyable
mc alias set local http://127.0.0.1:9000 {MINIO_ROOT_USER} {MINIO_ROOT_PASSWORD}
mc admin info local
Replace ``{MINIO_ROOT_USER}`` and ``{MINIO_ROOT_PASSWORD}`` with the credentials you defined for the container with the ``-e`` flags.
The :mc-cmd:`mc alias set` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
For additional details about this command, see :ref:`alias`.
.. dropdown:: MacOS
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO volume from the commandline.
.. tab-set::
.. tab-item:: Homebrew
Run the following command to install the latest stable MinIO Client package using `Homebrew <https://brew.sh>`_.
.. code-block:: shell
:class: copyable
brew install minio/stable/mc
.. tab-item:: Binary (arm64)
Run the following commands to install the latest stable MinIO Client package using a binary package for Apple chips.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/client/mc/release/darwin-arm64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
.. tab-item:: Binary (amd64)
Run the following commands to install the latest stable MinIO Client package using a binary package for Intel chips.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/client/mc/release/darwin-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
Use :mc-cmd:`mc alias set` to quickly authenticate and connect to the MinIO deployment.
.. code-block:: shell
:class: copyable
mc alias set local http://127.0.0.1:9000 {MINIO_ROOT_USER} {MINIO_ROOT_PASSWORD}
mc admin info local
Replace ``{MINIO_ROOT_USER}`` and ``{MINIO_ROOT_PASSWORD}`` with the credentials you defined for the container with the ``-e`` flags.
The :mc-cmd:`mc alias set` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
For additional details about this command, see :ref:`alias`.
.. dropdown:: Windows
Download the standalone MinIO server for Windows from the following link:
https://dl.min.io/client/mc/release/windows-amd64/mc.exe
Double click on the file to run it.
Or, run the following in the Command Prompt or PowerShell.
.. code-block::
:class: copyable
\path\to\mc.exe --help
Use :mc-cmd:`mc alias set` to quickly authenticate and connect to the MinIO deployment.
.. code-block:: shell
:class: copyable
mc.exe alias set local http://127.0.0.1:9000 {MINIO_ROOT_USER} {MINIO_ROOT_PASSWORD}
mc.exe admin info local
Replace ``{MINIO_ROOT_USER}`` and ``{MINIO_ROOT_PASSWORD}`` with the credentials you defined for the container with the ``-e`` flags.
The :mc-cmd:`mc alias set` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
For additional details about this command, see :ref:`alias`.
Next Steps
----------
- :ref:`Connect your applications to MinIO <minio-drivers>`
- :ref:`Configure Object Retention <minio-object-retention>`
- :ref:`Configure Security <minio-authentication-and-identity-management>`
- :ref:`Deploy MinIO in a Distrbuted Environment <deploy-minio-distributed>`

19
source/includes/k8s/deploy-operator.rst Normal file
View File

@ -0,0 +1,19 @@
.. _minio-operator-installation:
=========================
Deploy the MinIO Operator
=========================
.. default-domain:: minio
.. contents:: Table of Contents
:local:
:depth: 1
STUB - to be filled in
.. toctree::
:titlesonly:
:hidden:
/operations/install-deploy-manage/upgrade-minio-operator

166
source/includes/k8s/quickstart.rst Normal file
View File

@ -0,0 +1,166 @@
.. _quickstart-kubernetes:
=========================
Quickstart for Kubernetes
=========================
.. default-domain:: minio
.. |OS| replace:: Kubernetes
This procedure deploys a :ref:`Single-Node Single-Drive <minio-installation-comparison>` MinIO server onto |OS| for early development and evaluation of MinIO Object Storage and its S3-compatible API layer.
Use the :ref:`MinIO Opreator <minio-operator-installation>` to deploy and manage production-ready MinIO tenants on Kubernetes.
Prerequisites
-------------
- An existing Kubernetes deployment where *at least* one Worker Node has a locally-attached drive.
- A local ``kubectl`` installation configured to create and access resources on the target Kubernetes deployment.
- Familiarity with Kubernetes environments
- Familiarity with using a Terminal or Shell environment
Procedure
---------
#. **Download the MinIO Object**
.. tab-set::
.. tab-item:: Download the MinIO Kubernetes Object Definition
Download `minio-dev.yaml <https://raw.githubusercontent.com/minio/docs/master/source/extra/examples/minio-dev.yaml>`__ to your host machine:
.. code-block:: shell
:class: copyable
curl https://raw.githubusercontent.com/minio/docs/master/source/extra/examples/minio-dev.yaml -O
The file describes two Kubernetes resources:
- A new namespace ``minio-dev``, and
- A MinIO pod using a drive or volume on the Worker Node for serving data
Select the :guilabel:`Overview of the MinIO Object YAML` for a more detailed description of the object.
.. tab-item:: Overview of the MinIO Object YAML
The ``minio-dev.yaml`` contains the following Kubernetes resources:
.. literalinclude:: /extra/examples/minio-dev.yaml
:language: yaml
The object deploys two resources:
- A new namespace ``minio-dev``, and
- A MinIO pod using a drive or volume on the Worker Node for serving data
The MinIO resource definition uses Kubernetes :kube-docs:`Node Selectors and Labels <concepts/scheduling-eviction/assign-pod-node/#built-in-node-labels>` to restrict the pod to a node with matching hostname label.
Use ``kubectl get nodes --show-labels`` to view all labels assigned to each node in the cluster.
The MinIO Pod uses a :kube-docs:`hostPath <concepts/storage/volumes/#hostpath>` volume for storing data. This path *must* correspond to a local drive or folder on the Kubernetes worker node.
Users familiar with Kubernetes scheduling and volume provisioning may modify the ``spec.nodeSelector``, ``volumeMounts.name``, and ``volumes`` fields to meet more specific requirements.
#. **Apply the MinIO Object Definition**
The following command applies the ``minio-dev.yaml`` configuration and deploys the objects to Kubernetes:
.. code-block:: shell
:class: copyable
kubectl apply -f minio-dev.yaml
The command output should resemble the following:
.. code-block:: shell
namespace/minio-dev created
pod/minio created
You can verify the state of the pod by running ``kubectl get pods``:
.. code-block:: shell
:class: copyable
kubectl get pods -n minio-dev
The output should resemble the following:
.. code-block:: shell
NAME READY STATUS RESTARTS AGE
minio 1/1 Running 0 77s
You can also use the following commands to retrieve detailed information on the pod status:
.. code-block:: shell
:class: copyable
kubectl describe pod/minio -n minio-dev
kubectl logs pod/minio -n minio-dev
#. **Temporarily Access the MinIO S3 API and Console**
Use the ``kubectl port-forward`` command to temporarily forward traffic from the MinIO pod to the local machine:
.. code-block:: shell
:class: copyable
kubectl port-forward pod/minio 9000 9090
The command forwards the pod ports ``9000`` and ``9090`` to the matching port on the local machine while active in the shell.
The ``kubectl port-forward`` command only functions while active in the shell session.
Terminating the session closes the ports on the local machine.
.. note::
The following steps of this procedure assume an active ``kubectl port-forward`` command.
To configure long term access to the pod, configure :kube-docs:`Ingress <concepts/services-networking/ingress/>` or similar network control components within Kubernetes to route traffic to and from the pod. Configuring Ingress is out of the scope for this documentation.
#. **Connect your Browser to the MinIO Server**
Access the :ref:`minio-console` by opening a browser on the local machine and navigating to ``http://127.0.0.1:9090``.
Log in to the Console with the credentials ``minioadmin | minioadmin``.
These are the default :ref:`root user <minio-users-root>` credentials.
.. image:: /images/minio-console/console-login.png
:width: 600px
:alt: MinIO Console displaying login screen
:align: center
You can use the MinIO Console for general administration tasks like Identity and Access Management, Metrics and Log Monitoring, or Server Configuration.
Each MinIO server includes its own embedded MinIO Console.
.. image:: /images/minio-console/minio-console.png
:width: 600px
:alt: MinIO Console displaying bucket start screen
:align: center
For more information, see the :ref:`minio-console` documentation.
#. **(Optional) Connect the MinIO Client**
If your local machine has :mc:`mc` :ref:`installed <mc-install>`, use the :mc-cmd:`mc alias set` command to authenticate and connect to the MinIO deployment:
.. code-block:: shell
:class: copyable
mc alias set k8s-minio-dev http://127.0.0.1:9000 minioadmin minioadmin
mc admin info k8s-minio-dev
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
Next Steps
----------
- :ref:`Connect your applications to MinIO <minio-drivers>`
- :ref:`Configure Object Retention <minio-object-retention>`
- :ref:`Configure Security <minio-authentication-and-identity-management>`
- :ref:`Deploy MinIO for Production Environments <deploy-minio-distributed>`

261
source/includes/linux/common-installation.rst Normal file
View File

@ -0,0 +1,261 @@
.. start-install-minio-binary-desc
The following tabs provide examples of installing MinIO onto 64-bit Linux
operating systems using RPM, DEB, or binary. The RPM and DEB packages
automatically install MinIO to the necessary system paths and create a
``systemd`` service file for running MinIO automatically. MinIO strongly
recommends using RPM or DEB installation routes.
.. tab-set::
.. tab-item:: RPM (RHEL)
:sync: rpm
Use the following commands to download the latest stable MinIO RPM and
install it.
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-rpm| -O minio.deb
sudo dnf install minio.rpm
.. tab-item:: DEB (Debian/Ubuntu)
:sync: deb
Use the following commands to download the latest stable MinIO DEB and
install it:
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-deb| -O minio.deb
sudo dpkg -i minio.deb
.. tab-item:: Binary
:sync: binary
Use the following commands to download the latest stable MinIO binary and
install it to the system ``$PATH``:
.. code-block:: shell
:class: copyable
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
.. end-install-minio-binary-desc
.. start-run-minio-binary-desc
Run the :mc-cmd:`minio server` command to start the MinIO server.
Specify the path to the volume or folder to use as the storage directory.
The :mc-cmd:`minio` process must have full access (``rwx``) to the specified path and all subfolders:
The following example uses the ``~/minio-data`` folder:
.. code-block:: shell
:class: copyable
mkdir ~/minio-data
minio server ~/minio-data --console-address ":9090"
The :mc:`minio server` process prints its output to the system console, similar
to the following:
.. code-block:: shell
API: http://192.0.2.10:9000 http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin
Command-line: https://docs.min.io/docs/minio-client-quickstart-guide
$ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin
Documentation: https://docs.min.io
WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables
Open your browser to any of the listed :guilabel:`Console` addresses to open the
:ref:`MinIO Console <minio-console>` and log in with the :guilabel:`RootUser`
and :guilabel:`RootPass`. You can use the MinIO Console for performing
administration on the MinIO server.
For applications, use the :guilabel:`API` addresses to access the MinIO
server and perform S3 operations.
The following steps are optional but recommended for further securing the
MinIO deployment.
.. end-run-minio-binary-desc
.. start-upgrade-minio-binary-desc
The following tabs provide examples of updating MinIO onto 64-bit Linux
operating systems using RPM, DEB, or binary:
.. tab-set::
.. tab-item:: RPM (RHEL)
:sync: rpm
Use the following commands to download the latest stable MinIO RPM and
update the existing installation.
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-rpm| -O minio.deb
sudo dnf update minio.rpm
.. tab-item:: DEB (Debian/Ubuntu)
:sync: deb
Use the following commands to download the latest stable MinIO DEB and
upgrade the existing installation:
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-deb| -O minio.deb
sudo dpkg -i minio.deb
.. tab-item:: Binary
:sync: binary
Use the following commands to download the latest stable MinIO binary and
overwrite the existing binary:
.. code-block:: shell
:class: copyable
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
Replace ``/usr/local/bin`` with the location of the existing MinIO
binary. Run ``which minio`` to identify the path if not already known.
.. end-upgrade-minio-binary-desc
.. start-install-minio-systemd-desc
The ``.deb`` or ``.rpm`` packages install the following
`systemd <https://www.freedesktop.org/wiki/Software/systemd/>`__ service file to
``/etc/systemd/system/minio.service``. For binary installations, create this
file manually on all MinIO hosts:
.. code-block:: shell
:class: copyable
[Unit]
Description=MinIO
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio
[Service]
WorkingDirectory=/usr/local
User=minio-user
Group=minio-user
ProtectProc=invisible
EnvironmentFile=-/etc/default/minio
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_VOLUMES}\" ]; then echo \"Variable MINIO_VOLUMES not set in /etc/default/minio\"; exit 1; fi"
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
# Let systemd restart this service always
Restart=always
# Specifies the maximum file descriptor number that can be opened by this process
LimitNOFILE=65536
# Specifies the maximum number of threads this process can create
TasksMax=infinity
# Disable timeout logic and wait until process is stopped
TimeoutStopSec=infinity
SendSIGKILL=no
[Install]
WantedBy=multi-user.target
# Built for ${project.name}-${project.version} (${project.name})
The ``minio.service`` file runs as the ``minio-user`` User and Group by default.
You can create the user and group using the ``groupadd`` and ``useradd``
commands. The following example creates the user, group, and sets permissions
to access the folder paths intended for use by MinIO. These commands typically
require root (``sudo``) permissions.
.. code-block:: shell
:class: copyable
groupadd -r minio-user
useradd -M -r -g minio-user minio-user
chown minio-user:minio-user /mnt/disk1 /mnt/disk2 /mnt/disk3 /mnt/disk4
The specified disk paths are provided as an example. Change them to match
the path to those disks intended for use by MinIO.
Alternatively, change the ``User`` and ``Group`` values to another user and
group on the system host with the necessary access and permissions.
MinIO publishes additional startup script examples on
:minio-git:`github.com/minio/minio-service <minio-service>`.
.. end-install-minio-systemd-desc
.. start-install-minio-start-service-desc
.. code-block:: shell
:class: copyable
sudo systemctl start minio.service
Use the following commands to confirm the service is online and functional:
.. code-block:: shell
:class: copyable
sudo systemctl status minio.service
journalctl -f -u minio.service
MinIO may log an increased number of non-critical warnings while the
server processes connect and synchronize. These warnings are typically
transient and should resolve as the deployment comes online.
.. end-install-minio-start-service-desc
.. start-install-minio-restart-service-desc
.. code-block:: shell
:class: copyable
sudo systemctl restart minio.service
Use the following commands to confirm the service is online and functional:
.. code-block:: shell
:class: copyable
sudo systemctl status minio.service
journalctl -f -u minio.service
MinIO may log an increased number of non-critical warnings while the
server processes connect and synchronize. These warnings are typically
transient and should resolve as the deployment comes online.
.. end-install-minio-restart-service-desc

96
source/includes/linux/deploy-standalone.rst Normal file
View File

@ -0,0 +1,96 @@
1) Download the MinIO Server
----------------------------
The following tabs provide examples of installing MinIO onto 64-bit Linux
operating systems using RPM, DEB, or binary. The RPM and DEB packages
automatically install MinIO to the necessary system paths and create a
``systemd`` service file for running MinIO automatically. MinIO strongly
recommends using RPM or DEB installation routes.
.. tab-set::
.. tab-item:: RPM (RHEL)
:sync: rpm
Use the following commands to download the latest stable MinIO RPM and
install it.
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-rpm| -O minio.deb
sudo dnf install minio.rpm
.. tab-item:: DEB (Debian/Ubuntu)
:sync: deb
Use the following commands to download the latest stable MinIO DEB and
install it:
.. code-block:: shell
:class: copyable
:substitutions:
wget |minio-deb| -O minio.deb
sudo dpkg -i minio.deb
.. tab-item:: Binary
:sync: binary
Use the following commands to download the latest stable MinIO binary and
install it to the system ``$PATH``:
.. code-block:: shell
:class: copyable
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
2) Run the MinIO Server
-----------------------
Run the :mc-cmd:`minio server` command to start the MinIO server.
Specify the path to the volume or folder to use as the storage directory.
The :mc-cmd:`minio` process must have full access (``rwx``) to the specified path and all subfolders:
The following example uses the ``~/minio-data`` folder:
.. code-block:: shell
:class: copyable
mkdir ~/minio-data
minio server ~/minio-data --console-address ":9090"
The :mc:`minio server` process prints its output to the system console, similar
to the following:
.. code-block:: shell
API: http://192.0.2.10:9000 http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin
Command-line: https://docs.min.io/docs/minio-client-quickstart-guide
$ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin
Documentation: https://docs.min.io
WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables
Open your browser to any of the listed :guilabel:`Console` addresses to open the
:ref:`MinIO Console <minio-console>` and log in with the :guilabel:`RootUser`
and :guilabel:`RootPass`. You can use the MinIO Console for performing
administration on the MinIO server.
For applications, use the :guilabel:`API` addresses to access the MinIO
server and perform S3 operations.
The following steps are optional but recommended for further securing the
MinIO deployment.

130
source/includes/linux/quickstart.rst Normal file
View File

@ -0,0 +1,130 @@
.. _quickstart-linux:
====================
Quickstart for Linux
====================
.. default-domain:: minio
.. |OS| replace:: Linux
This procedure deploys a :ref:`Standalone <minio-installation-comparison>` MinIO server onto |OS| for early development and evaluation of MinIO Object Storage and its S3-compatible API layer.
For instructions on deploying to production environments, see :ref:`deploy-minio-distributed`.
Prerequisites
-------------
- Read, Write and Execute permissions on your local user folder (e.g. ``~/minio``).
- Permission to install binaries to the system ``PATH`` (e.g. access to ``/usr/local/bin``).
- Familiarity with the Linux terminal or shell (Bash, ZSH, etc.).
- A 64-bit Linux OS (e.g. RHEL 8, Ubuntu LTS releases).
Procedure
---------
#. **Install the MinIO Server**
.. include:: /includes/linux/common-installation.rst
:start-after: start-install-minio-binary-desc
:end-before: end-install-minio-binary-desc
#. **Launch the MinIO Server**
Run the following command from the system terminal or shell to start a local MinIO instance using the ``~/minio`` folder. You can replace this path with another folder path on the local machine:
.. code-block:: shell
:class: copyable
mkdir ~/minio
minio server ~/minio --console-address :9090
The ``mkdir`` command creates the folder explicitly at the specified path.
The ``minio server`` command starts the MinIO server. The path argument
``~/minio`` identifies the folder in which the server operates.
The :mc:`minio server` process prints its output to the system console, similar to the following:
.. code-block:: shell
API: http://192.0.2.10:9000 http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin
Command-line: https://docs.min.io/docs/minio-client-quickstart-guide
$ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin
Documentation: https://docs.min.io
WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables.
#. **Connect Your Browser to the MinIO Server**
Open http://127.0.0.1:9000 in a web browser to access the :ref:`MinIO Console <minio-console>`.
You can alternatively enter any of the network addresses specified as part of the server command output.
For example, :guilabel:`Console: http://192.0.2.10:9090 http://127.0.0.1:9090` in the example output indicates two possible addresses to use for connecting to the Console.
While the port ``9000`` is used for connecting to the API, MinIO automatically redirects browser access to the MinIO Console.
Log in to the Console with the ``RootUser`` and ``RootPass`` user credentials displayed in the output.
These default to ``minioadmin | minioadmin``.
.. image:: /images/minio-console/console-login.png
:width: 600px
:alt: MinIO Console displaying login screen
:align: center
You can use the MinIO Console for general administration tasks like Identity and Access Management, Metrics and Log Monitoring, or Server Configuration.
Each MinIO server includes its own embedded MinIO Console.
.. image:: /images/minio-console/minio-console.png
:width: 600px
:alt: MinIO Console displaying bucket start screen
:align: center
For more information, see the :ref:`minio-console` documentation.
#. `(Optional)` **Install the MinIO Client**
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO server from the commandline.
Download the :mc:`mc` client and install it to a location on your system ``PATH`` such as
``/usr/local/bin``. You can alternatively run the binary from the download location.
.. code-block:: shell
:class: copyable
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
Use :mc-cmd:`mc alias set` to create a new alias associated to your local deployment.
You can run :mc-cmd:`mc` commands against this alias:
.. code-block:: shell
:class: copyable
mc alias set local http://127.0.0.1:9000 minioadmin minioadmin
mc admin info local
The :mc-cmd:`mc alias set` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
The example above uses the :ref:`root user <minio-users-root>`.
Next Steps
----------
- :ref:`Connect your applications to MinIO <minio-drivers>`
- :ref:`Configure Object Retention <minio-object-retention>`
- :ref:`Configure Security <minio-authentication-and-identity-management>`
- :ref:`Deploy MinIO for Production Environments <deploy-minio-distributed>`

77
source/includes/macos/common-installation.rst Normal file
View File

@ -0,0 +1,77 @@
.. start-install-minio-binary-desc
.. tab-set::
.. tab-item:: Homebrew
Open a Terminal and run the following command to install the latest stable MinIO package using `Homebrew <https://brew.sh>`_.
.. code-block:: shell
:class: copyable
brew install minio/stable/minio
.. important::
If you previously installed the MinIO server using ``brew install minio``, then we recommend that you reinstall from ``minio/stable/minio`` instead.
.. code-block:: shell
:class: copyable
brew uninstall minio
brew install minio/stable/minio
.. tab-item:: Binary - arm64
Open a Terminal, then use the following commands to download the standalone MinIO server for MacOS and make it executable.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/server/minio/release/darwin-arm64/minio
chmod +x minio
.. tab-item:: Binary - amd64
Open a Terminal, then use the following commands to download the standalone MinIO server for MacOS and make it executable.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/server/minio/release/darwin-amd64/minio
chmod +x minio
.. end-install-minio-binary-desc
.. start-run-minio-binary-desc
From the Terminal, use the :mc:`minio server` to start a local MinIO instance in the ``~/data`` folder.
If desired, you can replace ``~/data`` with another location to which the user has read, write, and delete access for the MinIO instance.
.. code-block:: shell
:class: copyable
~/.minio server ~/data --console-address :9090
If you installed with Homebrew, do not include the ``~/`` at the beginning of the command.
The :mc:`minio server` process prints its output to the system console, similar to the following:
.. code-block:: shell
API: http://192.0.2.10:9000 http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin
Command-line: https://docs.min.io/docs/minio-client-quickstart-guide
$ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin
Documentation: https://docs.min.io
WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables.
.. end-run-minio-binary-desc

140
source/includes/macos/quickstart.rst Normal file
View File

@ -0,0 +1,140 @@
.. _quickstart-macos:
=======================
Quickstart for Mac OSX
=======================
.. default-domain:: minio
.. |OS| replace:: MacOS
This procedure deploys a :ref:`Single-Node Single-Drive <minio-installation-comparison>` MinIO server onto |OS| for early development and evaluation of MinIO Object Storage and its S3-compatible API layer.
For instructions on deploying to production environments, see :ref:`deploy-minio-distributed`.
Prerequisites
-------------
- Read, write, and execute permissions for the user's home directory
- Familiarity with using the Terminal
Procedure
---------
#. **Install the MinIO Server**
.. include:: /includes/macos/common-installation.rst
:start-after: start-install-minio-binary-desc
:end-before: end-install-minio-binary-desc
#. **Launch the MinIO Server**
.. include:: /includes/macos/common-installation.rst
:start-after: start-run-minio-binary-desc
:end-before: end-run-minio-binary-desc
#. **Connect your Browser to the MinIO Server**
Access the :ref:`minio-console` by going to a browser (such as Safari) and going to ``https://127.0.0.1:9000`` or one of the Console addresses specified in the :mc:`minio server` command's output.
For example, :guilabel:`Console: http://192.0.2.10:9090 http://127.0.0.1:9090` in the example output indicates two possible addresses to use for connecting to the Console.
While port ``9000`` is used for connecting to the API, MinIO automatically redirects browser access to the MinIO Console.
Log in to the Console with the ``RootUser`` and ``RootPass`` user credentials displayed in the output.
These default to ``minioadmin | minioadmin``.
.. image:: /images/minio-console/console-login.png
:width: 600px
:alt: MinIO Console displaying login screen
:align: center
You can use the MinIO Console for general administration tasks like Identity and Access Management, Metrics and Log Monitoring, or Server Configuration.
Each MinIO server includes its own embedded MinIO Console.
.. image:: /images/minio-console/minio-console.png
:width: 600px
:alt: MinIO Console displaying bucket start screen
:align: center
For more information, see the :ref:`minio-console` documentation.
#. `(Optional)` Install the MinIO Client
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO volume from the commandline.
.. tab-set::
.. tab-item:: Homebrew
Run the following commands to install the latest stable MinIO Client package using `Homebrew <https://brew.sh>`_.
.. code-block:: shell
:class: copyable
brew install minio/stable/mc
To use the command, run
.. code-block::
mc {command} {flag}
.. tab-item:: Binary (arm64)
Download the standalone MinIO server for MacOS and make it executable.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/client/mc/release/darwin-arm64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
To use the command, run
.. code-block:: shell
mc {command} {flag}
.. tab-item:: Binary (amd64)
Download the standalone MinIO server for MacOS and make it executable.
.. code-block:: shell
:class: copyable
curl -O https://dl.min.io/client/mc/release/darwin-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/mc
To use the command, run
.. code-block:: shell
mc {command} {flag}
Use :mc-cmd:`mc alias set` to quickly authenticate and connect to the MinIO deployment.
.. code-block:: shell
:class: copyable
mc alias set local http://127.0.0.1:9000 minioadmin minioadmin
mc admin info local
The :mc-cmd:`mc alias set` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
For additional details about this command, see :ref:`alias`.
Next Steps
----------
- :ref:`Connect your applications to MinIO <minio-drivers>`
- :ref:`Configure Object Retention <minio-object-retention>`
- :ref:`Configure Security <minio-authentication-and-identity-management>`
- :ref:`Deploy MinIO for Production Environments <deploy-minio-distributed>`

135
source/includes/windows/quickstart.rst Normal file
View File

@ -0,0 +1,135 @@
.. _quickstart-windows:
======================
Quickstart for Windows
======================
.. default-domain:: minio
.. |OS| replace:: Windows
This procedure deploys a :ref:`Single-Node Single-Drive <minio-installation-comparison>` MinIO server onto |OS| for early development and evaluation of MinIO Object Storage and its S3-compatible API layer.
For instructions on deploying to production environments, see :ref:`deploy-minio-distributed`.
Prerequisites
-------------
- Read, write, and execute permissions for the preferred local directory or file path
- Familiarity with using the Command Prompt or PowerShell
Procedure
---------
#. Install the MinIO Server
Download the MinIO executable from the following URL:
.. code-block:: shell
:class: copyable
https://dl.min.io/server/minio/release/windows-amd64/minio.exe
The next step includes instructions for running the executable.
You cannot run the executable from the Explorer or by double clicking the file.
Instead, you call the executable to launch the server.
#. Launch the :mc:`minio server`
In PowerShell or the Command Prompt, navigate to the location of the executable or add the path of the ``minio.exe`` file to the system ``$PATH``.
Use this command to start a local MinIO instance in the ``C:\minio`` folder.
You can replace ``C:\minio`` with another drive or folder path on the local computer.
.. code-block::
:class: copyable
.\minio.exe server C:\minio --console-address :9090
The :mc:`minio server` process prints its output to the system console, similar to the following:
.. code-block:: shell
API: http://192.0.2.10:9000 http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin
Command-line: https://docs.min.io/docs/minio-client-quickstart-guide
$ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin
Documentation: https://docs.min.io
WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables.
The process is tied to the current PowerShell or Command Prompt window.
Closing the window stops the server and ends the process.
#. Connect your Browser to the MinIO Server
Access the :ref:`minio-console` by going to a browser (such as Microsoft Edge) and going to ``http://127.0.0.1:9000`` or one of the Console addresses specified in the :mc:`minio server` command's output.
For example, :guilabel:`Console: http://192.0.2.10:9090 http://127.0.0.1:9090` in the example output indicates two possible addresses to use for connecting to the Console.
While port ``9000`` is used for connecting to the API, MinIO automatically redirects browser access to the MinIO Console.
Log in to the Console with the ``RootUser`` and ``RootPass`` user credentials displayed in the output.
These default to ``minioadmin | minioadmin``.
.. image:: /images/minio-console/console-login.png
:width: 600px
:alt: MinIO Console displaying login screen
:align: center
You can use the MinIO Console for general administration tasks like Identity and Access Management, Metrics and Log Monitoring, or Server Configuration.
Each MinIO server includes its own embedded MinIO Console.
.. image:: /images/minio-console/minio-console.png
:width: 600px
:alt: MinIO Console displaying bucket start screen
:align: center
For more information, see the :ref:`minio-console` documentation.
#. `(Optional)` Install the MinIO Client
The :ref:`MinIO Client <minio-client>` allows you to work with your MinIO volume from the commandline.
Download the standalone MinIO server for Windows from the following link:
https://dl.min.io/client/mc/release/windows-amd64/mc.exe
Double click on the file to run it.
Or, run the following in the Command Prompt or PowerShell.
.. code-block::
:class: copyable
\path\to\mc.exe --help
Use :mc-cmd:`mc.exe alias set <mc alias set>` to quickly authenticate and connect to the MinIO deployment.
.. code-block:: shell
:class: copyable
mc.exe alias set local http://127.0.0.1:9000 minioadmin minioadmin
mc.exe admin info local
The :mc-cmd:`mc.exe alias set <mc alias set>` takes four arguments:
- The name of the alias
- The hostname or IP address and port of the MinIO server
- The Access Key for a MinIO :ref:`user <minio-users>`
- The Secret Key for a MinIO :ref:`user <minio-users>`
For additional details about this command, see :ref:`alias`.
Next Steps
----------
- :ref:`Connect your applications to MinIO <minio-drivers>`
- :ref:`Configure Object Retention <minio-object-retention>`
- :ref:`Configure Security <minio-authentication-and-identity-management>`
- :ref:`Deploy MinIO for Production Environments <deploy-minio-distributed>`