MinIO: Comenzando

Cómo empezar a usar MinIO para almacenamiento de objetos compatible con S3

👋 ¡Bienvenido a la documentación de Stackhero!

Stackhero ofrece una solución MinIO Object Storage lista para usar que proporciona una serie de beneficios, incluyendo:

Transferencias ilimitadas.

Precios simples, predictivos y transparentes.

Nombre de dominio personalizable asegurado con HTTPS (por ejemplo, https://object-storage.tu-empresa.com).

Actualizaciones sin esfuerzo con solo un clic.

Rendimiento óptimo y seguridad robusta impulsados por una VM privada y dedicada.

Disponible en 🇪🇺 Europa y 🇺🇸 USA.

Ahorre tiempo y simplifique su vida: ¡solo toma 5 minutos probar la solución de alojamiento MinIO Object Storage de Stackhero!

MinIO es un servicio de almacenamiento de objetos que implementa el protocolo Amazon S3. Cualquier cliente compatible con Amazon S3 puede conectarse a MinIO e interactuar sin problemas con su almacenamiento de objetos. Hay una biblioteca cliente de Amazon S3 disponible para casi todos los principales lenguajes de programación, incluidos Ruby, Node.js, Java, Python, Clojure y Erlang.

Recomendamos usar los SDK de MinIO para conectarse a su almacenamiento de objetos. Puede encontrar una lista completa de los SDK disponibles en la documentación oficial de MinIO.

Alternativamente, puede usar la CLI de MinIO. Es especialmente útil para gestionar archivos grandes directamente desde su terminal. Guías detalladas sobre el uso de la CLI de MinIO están disponibles en la documentación oficial de la CLI de MinIO.

Uso de la CLI de MinIO

Su instancia de Stackhero for MinIO incluye por defecto la interfaz web MinIO Console. Para tareas más avanzadas, puede optar por usar la CLI de MinIO.

La forma más sencilla de probar la CLI de MinIO es ejecutar su contenedor Docker. Siga estos pasos:

Inicie el contenedor:

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

Dentro del contenedor, añada su servidor usando el siguiente comando (reemplace los valores de marcador de posición según corresponda):
```
mc alias set minio https://<XXXXXX>.stackhero-network.com <ROOT_ACCESS_KEY> <MINIO_ROOT_SECRET_KEY>
```
Cree un bucket llamado "test" para verificar la configuración:
```
mc mb minio/test
```
Liste sus buckets:
```
mc ls minio
```

Puede ver comandos adicionales de la CLI de MinIO ejecutando mc --help.

Conectando Ruby a MinIO

Primero, instale el gem AWS SDK:

gem install aws-sdk
bundle install

A continuación se muestra un ejemplo simple que demuestra cómo interactuar con MinIO usando el AWS SDK en 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

# operación put_object
rubys3_client.put_object(
  key: 'testobject',
  body: 'Hello from MinIO!',
  bucket: 'testbucket',
  content_type: 'text/plain'
)

# operación get_object
rubys3_client.get_object(
  bucket: 'testbucket',
  key: 'testobject',
  response_target: 'download_testobject'
)

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

Para más detalles, consulte la documentación de Ruby de MinIO.

Conectando Python a MinIO

Hay dos formas principales de conectar aplicaciones Python a MinIO.

Conectando a MinIO con el AWS SDK (boto)

Primero, instale el paquete AWS SDK (boto3):

pip install boto3
pip freeze > requirements.txt

El siguiente ejemplo demuestra cómo conectarse a 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')

# Subir un archivo local '/home/john/piano.mp3' al bucket 'songs' con el nombre de objeto 'piano.mp3'
s3.Bucket('songs').upload_file('/home/john/piano.mp3', 'piano.mp3')

# Descargar el objeto 'piano.mp3' del bucket 'songs' y guardarlo localmente como '/tmp/classical.mp3'
s3.Bucket('songs').download_file('piano.mp3', '/tmp/classical.mp3')

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

Más detalles están disponibles en la documentación de Python de MinIO.

Conectando a MinIO con el SDK de MinIO

Alternativamente, puede usar el SDK de MinIO para Python. Primero, instale el paquete MinIO:

pip install minio
pip freeze > requirements.txt

A continuación se muestra un ejemplo que muestra cómo conectarse a MinIO usando el SDK de MinIO:

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

def main():
  # Cree un cliente para su servidor MinIO usando sus claves de acceso y secretas
  client = Minio(
    endpoint='<XXXXXX>.stackhero-network.com:443',
    secure=True,
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
  )

  # Verifique si el bucket 'asiatrip' existe, y créelo si no existe
  found = client.bucket_exists("asiatrip")
  if not found:
    client.make_bucket("asiatrip")
  else:
    print("Bucket 'asiatrip' already exists")

  # Suba '/home/user/Photos/asiaphotos.zip' como 'asiaphotos-2015.zip' al 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 más información, consulte la documentación del SDK de Python de MinIO.

Conectando PHP a MinIO

Para conectar PHP a MinIO, primero instale el paquete AWS SDK para PHP:

composer require aws/aws-sdk-php

El ejemplo a continuación muestra cómo conectarse a MinIO desde PHP usando el AWS SDK:

<?php

// Incluya el SDK usando el autoloader de 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'
  ],
]);

// Envíe una solicitud PutObject y obtenga el resultado.
$insert = $s3->putObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'Body'   => 'Hello from MinIO!'
]);

// Descargue el contenido del objeto.
$retrieve = $s3->getObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'SaveAs' => 'testkey_local'
]);

// Imprima el cuerpo del resultado recuperado.
echo $retrieve['Body'];

Conectando Go a MinIO

Hay dos opciones para conectar aplicaciones Go a MinIO.

Conectando a MinIO con el AWS SDK

Primero, instale los paquetes AWS SDK para Go:

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

A continuación se muestra un ejemplo de cómo conectarse a MinIO desde Go usando el 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 el 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,
  }

  // Cree un nuevo bucket
  _, err := s3Client.CreateBucket(cparams)
  if err != nil {
    fmt.Println(err.Error())
    return
  }

  // Suba un nuevo objeto con la cadena "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 nuestro objeto y guárdelo 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 lecturas adicionales, visite la documentación de Go de MinIO.

Conectando a MinIO con el SDK de MinIO

Para usar el SDK de MinIO para Go, instale el siguiente paquete:

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

A continuación se muestra un ejemplo que muestra cómo conectarse a MinIO usando el SDK de 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

  // Inicialice el 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 ahora está configurado
}

Para más información, consulte la documentación del SDK de Go de MinIO.

Conectando Node.js a MinIO

Hay dos métodos para conectar aplicaciones Node.js a MinIO.

Conectando a MinIO con el AWS SDK

Primero, instale el paquete AWS SDK para Node.js:

npm install aws-sdk

A continuación se muestra un ejemplo que muestra cómo conectarse a MinIO usando el 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, // requerido con MinIO
  signatureVersion: 'v4'
});

// operación 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');
  }
);

// operación 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 más detalles, visite la documentación de Node.js de MinIO.

Conectando a MinIO con el SDK de MinIO

Si prefiere usar el SDK de MinIO para Node.js, instálelo usando npm:

npm install minio

Aquí hay un ejemplo de cómo conectarse a MinIO usando el SDK de MinIO para Node.js:

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

// Instancie el cliente MinIO con el endpoint y las claves de acceso
const minioClient = new Minio.Client({
  endpoint: '<XXXXXX>.stackhero-network.com',
  port: 443,
  useSSL: true,
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
});

// Archivo a subir
const file = '/tmp/photos-europe.tar';

// Cree un bucket llamado '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
    };
    // Suba el archivo al bucket 'europetrip' usando la API fPutObject
    minioClient.fPutObject(
      'europetrip',
      'photos-europe.tar',
      file,
      metaData,
      (err, etag) => {
        if (err) return console.log(err);
        console.log('File uploaded successfully.');
      }
    );
  }
);

Para más información, consulte la documentación del SDK de Node.js de MinIO.