MinIO: Premiers pas

Comment commencer à utiliser MinIO pour le stockage d'objets compatible S3

👋 Bienvenue sur la documentation de Stackhero !

Stackhero propose une solution MinIO Object Storage prête à l'emploi qui offre de nombreux avantages, notamment :

  • Transferts illimités.
  • Tarification simple, prédictive et transparente.
  • Nom de domaine personnalisable sécurisé avec HTTPS (par exemple, https://object-storage.votre-entreprise.com).
  • Mises à jour sans effort en un clic.
  • Performance optimale et sécurité robuste grâce à une VM privée et dédiée.
  • Disponible en 🇪🇺 Europe et 🇺🇸 USA.

Gagnez du temps et simplifiez-vous la vie : il suffit de 5 minutes pour essayer la solution d'hébergement MinIO Object Storage de Stackhero !

MinIO est un service de stockage d'objets qui implémente le protocole Amazon S3. Tout client compatible Amazon S3 peut se connecter à MinIO et interagir sans problème avec votre stockage d'objets. Une bibliothèque client Amazon S3 est disponible pour presque tous les principaux langages de programmation, y compris Ruby, Node.js, Java, Python, Clojure et Erlang.

Nous recommandons d'utiliser les SDK MinIO pour vous connecter à votre stockage d'objets. Vous pouvez trouver une liste complète des SDK disponibles dans la documentation officielle de MinIO.

Alternativement, vous pouvez utiliser la CLI MinIO. Elle est particulièrement utile pour gérer de gros fichiers directement depuis votre terminal. Des instructions détaillées sur l'utilisation de la CLI MinIO sont disponibles dans la documentation officielle de la CLI MinIO.

Utilisation de la CLI MinIO

Votre instance Stackhero for MinIO inclut par défaut l'interface web MinIO Console. Pour des tâches plus avancées, vous pouvez choisir d'utiliser la CLI MinIO.

La manière la plus simple d'essayer la CLI MinIO est d'exécuter son conteneur Docker. Suivez ces étapes :

  1. Démarrez le conteneur :

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

  2. À l'intérieur du conteneur, ajoutez votre serveur en utilisant la commande suivante (remplacez les valeurs de remplacement en conséquence) :

    mc alias set minio https://<XXXXXX>.stackhero-network.com <ROOT_ACCESS_KEY> <MINIO_ROOT_SECRET_KEY>

  3. Créez un bucket nommé "test" pour vérifier la configuration :

    mc mb minio/test

  4. Listez vos buckets :

    mc ls minio

Vous pouvez voir des commandes supplémentaires de la CLI MinIO en exécutant mc --help.

Connexion de Ruby à MinIO

Tout d'abord, installez le gem AWS SDK :

gem install aws-sdk
bundle install

Voici un exemple simple montrant comment interagir avec MinIO en utilisant l'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

# opération put_object
rubys3_client.put_object(
  key: 'testobject',
  body: 'Hello from MinIO!',
  bucket: 'testbucket',
  content_type: 'text/plain'
)

# opération get_object
rubys3_client.get_object(
  bucket: 'testbucket',
  key: 'testobject',
  response_target: 'download_testobject'
)

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

Pour plus de détails, consultez la documentation Ruby de MinIO.

Connexion de Python à MinIO

Il existe deux principales façons de connecter des applications Python à MinIO.

Connexion à MinIO avec l'AWS SDK (boto)

Tout d'abord, installez le package AWS SDK (boto3) :

pip install boto3
pip freeze > requirements.txt

L'exemple suivant montre comment se connecter à MinIO en utilisant 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')

# Téléchargez un fichier local '/home/john/piano.mp3' vers le bucket 'songs' avec le nom d'objet 'piano.mp3'
s3.Bucket('songs').upload_file('/home/john/piano.mp3', 'piano.mp3')

# Téléchargez l'objet 'piano.mp3' du bucket 'songs' et enregistrez-le localement sous '/tmp/classical.mp3'
s3.Bucket('songs').download_file('piano.mp3', '/tmp/classical.mp3')

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

Plus de détails sont disponibles dans la documentation Python de MinIO.

Connexion à MinIO avec le SDK MinIO

Alternativement, vous pouvez utiliser le SDK MinIO pour Python. Tout d'abord, installez le package MinIO :

pip install minio
pip freeze > requirements.txt

Voici un exemple montrant comment se connecter à MinIO en utilisant le SDK MinIO :

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

def main():
  # Créez un client pour votre serveur MinIO en utilisant vos clés d'accès et secrètes
  client = Minio(
    endpoint='<XXXXXX>.stackhero-network.com:443',
    secure=True,
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
  )

  # Vérifiez si le bucket 'asiatrip' existe, et créez-le s'il n'existe pas
  found = client.bucket_exists("asiatrip")
  if not found:
    client.make_bucket("asiatrip")
  else:
    print("Bucket 'asiatrip' already exists")

  # Téléchargez '/home/user/Photos/asiaphotos.zip' sous 'asiaphotos-2015.zip' dans le 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)

Pour plus d'informations, consultez la documentation du SDK Python de MinIO.

Connexion de PHP à MinIO

Pour connecter PHP à MinIO, installez d'abord le package AWS SDK pour PHP :

composer require aws/aws-sdk-php

L'exemple ci-dessous montre comment se connecter à MinIO depuis PHP en utilisant l'AWS SDK :

<?php

// Incluez le SDK en utilisant l'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'
  ],
]);

// Envoyez une requête PutObject et obtenez le résultat.
$insert = $s3->putObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'Body'   => 'Hello from MinIO!'
]);

// Téléchargez le contenu de l'objet.
$retrieve = $s3->getObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'SaveAs' => 'testkey_local'
]);

// Imprimez le corps du résultat récupéré.
echo $retrieve['Body'];

Connexion de Go à MinIO

Il existe deux options pour connecter des applications Go à MinIO.

Connexion à MinIO avec l'AWS SDK

Tout d'abord, installez les packages AWS SDK pour Go :

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

Voici un exemple de connexion à MinIO depuis Go en utilisant l'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")

  // Configurez pour utiliser le serveur 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,
  }

  // Créez un nouveau bucket
  _, err := s3Client.CreateBucket(cparams)
  if err != nil {
    fmt.Println(err.Error())
    return
  }

  // Téléchargez un nouvel objet avec la chaîne "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)

  // Récupérez notre objet et stockez-le localement
  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")
}

Pour des lectures supplémentaires, visitez la documentation Go de MinIO.

Connexion à MinIO avec le SDK MinIO

Pour utiliser le SDK MinIO pour Go, installez le package suivant :

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

Voici un exemple montrant comment se connecter à MinIO en utilisant le SDK MinIO pour 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

  // Initialisez le client 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 maintenant configuré
}

Pour plus d'informations, veuillez consulter la documentation du SDK Go de MinIO.

Connexion de Node.js à MinIO

Il existe deux méthodes pour connecter des applications Node.js à MinIO.

Connexion à MinIO avec l'AWS SDK

Tout d'abord, installez le package AWS SDK pour Node.js :

npm install aws-sdk

Voici un exemple qui montre comment se connecter à MinIO en utilisant l'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, // requis avec MinIO
  signatureVersion: 'v4'
});

// opération 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');
  }
);

// opération 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();

Pour plus de détails, visitez la documentation Node.js de MinIO.

Connexion à MinIO avec le SDK MinIO

Si vous préférez utiliser le SDK MinIO pour Node.js, installez-le en utilisant npm :

npm install minio

Voici un exemple de connexion à MinIO en utilisant le SDK MinIO pour Node.js :

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

// Instanciez le client MinIO avec l'endpoint et les clés d'accès
const minioClient = new Minio.Client({
  endpoint: '<XXXXXX>.stackhero-network.com',
  port: 443,
  useSSL: true,
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
});

// Fichier à télécharger
const file = '/tmp/photos-europe.tar';

// Créez un bucket appelé '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
    };
    // Téléchargez le fichier dans le bucket 'europetrip' en utilisant l'API fPutObject
    minioClient.fPutObject(
      'europetrip',
      'photos-europe.tar',
      file,
      metaData,
      (err, etag) => {
        if (err) return console.log(err);
        console.log('File uploaded successfully.');
      }
    );
  }
);

Pour plus d'informations, consultez la documentation du SDK Node.js de MinIO.