MinIO: Introdução

Como começar a usar o MinIO para armazenamento de objetos compatível com S3

👋 Bem-vindo à documentação da Stackhero!

A Stackhero oferece uma solução MinIO Object Storage pronta a usar que proporciona uma série de benefícios, incluindo:

Transferências ilimitadas.

Preços simples, previsíveis e transparentes.

Nome de domínio personalizável seguro com HTTPS (por exemplo, https://object-storage.sua-empresa.com).

Atualizações sem esforço com apenas um clique.

Desempenho ótimo e segurança robusta alimentados por uma VM privada e dedicada.

Disponível na 🇪🇺 Europa e nos 🇺🇸 EUA.

Poupe tempo e simplifique a sua vida: são necessários apenas 5 minutos para experimentar a solução de alojamento MinIO Object Storage da Stackhero!

O MinIO é um serviço de armazenamento de objetos que implementa o protocolo Amazon S3. Qualquer cliente compatível com Amazon S3 pode conectar-se ao MinIO e interagir sem problemas com o seu armazenamento de objetos. Uma biblioteca cliente Amazon S3 está disponível para quase todas as principais linguagens de programação, incluindo Ruby, Node.js, Java, Python, Clojure e Erlang.

Recomendamos usar os SDKs do MinIO para conectar-se ao seu armazenamento de objetos. Pode encontrar uma lista completa dos SDKs disponíveis na documentação oficial do MinIO.

Alternativamente, pode usar o MinIO CLI. É especialmente útil para gerir grandes ficheiros diretamente a partir do seu terminal. Orientações detalhadas sobre o uso do MinIO CLI estão disponíveis na documentação oficial do MinIO CLI.

Usando o MinIO CLI

A sua instância Stackhero for MinIO inclui por padrão a interface web MinIO Console. Para tarefas mais avançadas, pode optar por usar o MinIO CLI.

A maneira mais simples de experimentar o MinIO CLI é executar o seu contentor Docker. Siga estes passos:

Inicie o contentor:

docker run -it --entrypoint=/bin/sh minio/mc

Dentro do contentor, adicione o seu servidor usando o seguinte comando (substitua os valores de exemplo conforme necessário):
```
mc alias set minio https://<XXXXXX>.stackhero-network.com <ROOT_ACCESS_KEY> <MINIO_ROOT_SECRET_KEY>
```
Crie um bucket chamado "test" para verificar a configuração:
```
mc mb minio/test
```
Liste os seus buckets:
```
mc ls minio
```

Pode ver comandos adicionais do MinIO CLI executando mc --help.

Conectando Ruby ao MinIO

Primeiro, instale o gem AWS SDK:

gem install aws-sdk
bundle install

Abaixo está um exemplo simples que demonstra como interagir com o MinIO usando o AWS SDK em Ruby:

require 'aws-sdk'

Aws.config.update(
  endpoint: 'https://<XXXXXX>.stackhero-network.com',
  access_key_id: 'YOUR_ACCESS_KEY',
  secret_access_key: 'YOUR_SECRET_KEY',
  force_path_style: true,
  region: 'us-east-1'
)

rubys3_client = Aws::S3::Client.new

# operação put_object
rubys3_client.put_object(
  key: 'testobject',
  body: 'Hello from MinIO!',
  bucket: 'testbucket',
  content_type: 'text/plain'
)

# operação get_object
rubys3_client.get_object(
  bucket: 'testbucket',
  key: 'testobject',
  response_target: 'download_testobject'
)

print "Downloaded 'testobject' as 'download_testobject'."

Para mais detalhes, consulte a documentação Ruby do MinIO.

Conectando Python ao MinIO

Existem duas principais formas de conectar aplicações Python ao MinIO.

Conectando ao MinIO com o AWS SDK (boto)

Primeiro, instale o pacote AWS SDK (boto3):

pip install boto3
pip freeze > requirements.txt

O exemplo seguinte demonstra como conectar-se ao MinIO usando boto3:

#!/usr/bin/env python
import os
import boto3
from botocore.client import Config

s3 = boto3.resource('s3',
                    endpoint_url='https://<XXXXXX>.stackhero-network.com',
                    aws_access_key_id='YOUR_ACCESS_KEY',
                    aws_secret_access_key='YOUR_SECRET_KEY',
                    config=Config(signature_version='s3v4'),
                    region_name='us-east-1')

# Carregar um ficheiro local '/home/john/piano.mp3' para o bucket 'songs' com o nome de objeto 'piano.mp3'
s3.Bucket('songs').upload_file('/home/john/piano.mp3', 'piano.mp3')

# Descarregar o objeto 'piano.mp3' do bucket 'songs' e guardá-lo localmente como '/tmp/classical.mp3'
s3.Bucket('songs').download_file('piano.mp3', '/tmp/classical.mp3')

print("'piano.mp3' downloaded as 'classical.mp3'.")

Mais detalhes estão disponíveis na documentação Python do MinIO.

Conectando ao MinIO com o SDK MinIO

Alternativamente, pode usar o SDK MinIO para Python. Primeiro, instale o pacote MinIO:

pip install minio
pip freeze > requirements.txt

Abaixo está um exemplo que mostra como conectar-se ao MinIO usando o SDK MinIO:

#!/usr/bin/env python
from minio import Minio
from minio.error import S3Error

def main():
  # Crie um cliente para o seu servidor MinIO usando as suas chaves de acesso e secretas
  client = Minio(
    endpoint='<XXXXXX>.stackhero-network.com:443',
    secure=True,
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
  )

  # Verifique se o bucket 'asiatrip' existe, e crie-o se não existir
  found = client.bucket_exists("asiatrip")
  if not found:
    client.make_bucket("asiatrip")
  else:
    print("Bucket 'asiatrip' already exists")

  # Carregar '/home/user/Photos/asiaphotos.zip' como 'asiaphotos-2015.zip' para o bucket 'asiatrip'
  client.fput_object(
    "asiatrip", "asiaphotos-2015.zip", "/home/user/Photos/asiaphotos.zip"
  )
  print(
    "'/home/user/Photos/asiaphotos.zip' has been successfully uploaded as "
    "object 'asiaphotos-2015.zip' to bucket 'asiatrip'."
  )


if __name__ == "__main__":
  try:
    main()
  except S3Error as exc:
    print("An error occurred.", exc)

Para mais informações, consulte a documentação do SDK Python do MinIO.

Conectando PHP ao MinIO

Para conectar PHP ao MinIO, primeiro instale o pacote AWS SDK para PHP:

composer require aws/aws-sdk-php

O exemplo abaixo mostra como conectar-se ao MinIO a partir do PHP usando o AWS SDK:

<?php

// Inclua o SDK usando o autoloader do Composer
date_default_timezone_set('America/Los_Angeles');
require 'vendor/autoload.php';

$s3 = new Aws\S3\S3Client([
  'version' => 'latest',
  'region'  => 'us-east-1',
  'endpoint' => 'https://<XXXXXX>.stackhero-network.com',
  'use_path_style_endpoint' => true,
  'credentials' => [
    'key'    => 'YOUR_ACCESS_KEY',
    'secret' => 'YOUR_SECRET_KEY'
  ],
]);

// Envie uma solicitação PutObject e obtenha o resultado.
$insert = $s3->putObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'Body'   => 'Hello from MinIO!'
]);

// Descarregue o conteúdo do objeto.
$retrieve = $s3->getObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'SaveAs' => 'testkey_local'
]);

// Imprima o corpo do resultado recuperado.
echo $retrieve['Body'];

Conectando Go ao MinIO

Existem duas opções para conectar aplicações Go ao MinIO.

Conectando ao MinIO com o AWS SDK

Primeiro, instale os pacotes AWS SDK para Go:

go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config

Abaixo está um exemplo de como conectar-se ao MinIO a partir do Go usando o AWS SDK:

package main

import (
  "fmt"
  "os"
  "strings"

  "github.com/aws/aws-sdk-go/aws"
  "github.com/aws/aws-sdk-go/aws/credentials"
  "github.com/aws/aws-sdk-go/aws/session"
  "github.com/aws/aws-sdk-go/service/s3"
  "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

func main() {
  bucket := aws.String("newbucket")
  key := aws.String("testobject")

  // Configure para usar o servidor MinIO
  s3Config := &aws.Config{
    Credentials:      credentials.NewStaticCredentials("YOUR_ACCESS_KEY", "YOUR_SECRET_KEY", ""),
    Endpoint:         aws.String("https://<XXXXXX>.stackhero-network.com"),
    Region:           aws.String("us-east-1"),
    DisableSSL:       aws.Bool(false),
    S3ForcePathStyle: aws.Bool(true),
  }
  newSession := session.New(s3Config)

  s3Client := s3.New(newSession)

  cparams := &s3.CreateBucketInput{
    Bucket: bucket,
  }

  // Crie um novo bucket
  _, err := s3Client.CreateBucket(cparams)
  if err != nil {
    fmt.Println(err.Error())
    return
  }

  // Carregar um novo objeto com a string "Hello from MinIO!"
  _, err = s3Client.PutObject(&s3.PutObjectInput{
    Body:   strings.NewReader("Hello from MinIO!"),
    Bucket: bucket,
    Key:    key,
  })
  if err != nil {
    fmt.Printf("Failed to upload data to %s/%s, %s\n", *bucket, *key, err.Error())
    return
  }
  fmt.Printf("Successfully created bucket %s and uploaded data with key %s\n", *bucket, *key)

  // Recupere o nosso objeto e armazene-o localmente
  file, err := os.Create("testobject_local")
  if err != nil {
    fmt.Println("Failed to create file", err)
    return
  }
  defer file.Close()

  downloader := s3manager.NewDownloader(newSession)
  numBytes, err := downloader.Download(file,
    &s3.GetObjectInput{
      Bucket: bucket,
      Key:    key,
    })
  if err != nil {
    fmt.Println("Failed to download file", err)
    return
  }
  fmt.Println("Downloaded file", file.Name(), numBytes, "bytes")
}

Para leitura adicional, visite a documentação Go do MinIO.

Conectando ao MinIO com o SDK MinIO

Para usar o SDK MinIO para Go, instale o seguinte pacote:

GO111MODULE=on go get github.com/minio/minio-go/v7

Abaixo está um exemplo que mostra como conectar-se ao MinIO usando o SDK MinIO para Go:

package main

import (
  "log"

  "github.com/minio/minio-go/v7"
  "github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
  endpoint := "<XXXXXX>.stackhero-network.com"
  accessKeyID := "YOUR_ACCESS_KEY"
  secretAccessKey := "YOUR_SECRET_KEY"
  useSSL := true

  // Inicialize o cliente MinIO
  minioClient, err := minio.New(endpoint, &minio.Options{
    Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
    Secure: useSSL,
  })
  if err != nil {
    log.Fatalln(err)
  }

  log.Printf("%#v\n", minioClient) // minioClient está agora configurado
}

Para mais informações, consulte a documentação do SDK Go do MinIO.

Conectando Node.js ao MinIO

Existem dois métodos para conectar aplicações Node.js ao MinIO.

Conectando ao MinIO com o AWS SDK

Primeiro, instale o pacote AWS SDK para Node.js:

npm install aws-sdk

Abaixo está um exemplo que mostra como conectar-se ao MinIO usando o AWS SDK:

const process = require('process');
const AWS = require('aws-sdk');

const s3 = new AWS.S3({
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
  endpoint: 'https://<XXXXXX>.stackhero-network.com',
  s3ForcePathStyle: true, // necessário com MinIO
  signatureVersion: 'v4'
});

// operação putObject
s3.putObject(
  { Bucket: 'testbucket', Key: 'testobject', Body: 'Hello from MinIO!' },
  (err, data) => {
    if (err)
      console.log(err);
    else
      console.log('Successfully uploaded data to testbucket/testobject');
  }
);

// operação getObject
const file = require('fs').createWriteStream('/tmp/mykey');
s3.getObject({ Bucket: 'testbucket', Key: 'testobject' })
  .on('httpData', chunk => file.write(chunk))
  .on('httpDone', () => file.end())
  .send();

Para mais detalhes, visite a documentação Node.js do MinIO.

Conectando ao MinIO com o SDK MinIO

Se preferir usar o SDK MinIO para Node.js, instale-o usando npm:

npm install minio

Aqui está um exemplo de como conectar-se ao MinIO usando o SDK MinIO para Node.js:

const process = require('process');
const Minio = require('minio');

// Instancie o cliente MinIO com o endpoint e as chaves de acesso
const minioClient = new Minio.Client({
  endpoint: '<XXXXXX>.stackhero-network.com',
  port: 443,
  useSSL: true,
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
});

// Ficheiro a ser carregado
const file = '/tmp/photos-europe.tar';

// Crie um bucket chamado 'europetrip'
minioClient.makeBucket(
  'europetrip',
  'us-east-1',
  err => {
    if (err) return console.log(err);

    console.log('Bucket created successfully in "us-east-1".');

    const metaData = {
      'Content-Type': 'application/octet-stream',
      'X-Amz-Meta-Testing': 1234,
      'example': 5678
    };
    // Carregar o ficheiro para o bucket 'europetrip' usando a API fPutObject
    minioClient.fPutObject(
      'europetrip',
      'photos-europe.tar',
      file,
      metaData,
      (err, etag) => {
        if (err) return console.log(err);
        console.log('File uploaded successfully.');
      }
    );
  }
);

Para mais informações, consulte a documentação do SDK Node.js do MinIO.