MinIO: Premiers pas

Comment débuter avec MinIO pour l'object storage 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 :

Des transferts illimités.

Une tarification simple, prévisible et transparente.

Un nom de domaine personnalisable sécurisé par HTTPS (par exemple, https://object-storage.votre-entreprise.com).

Des mises à jour faciles en un clic.

Une performance optimale et une sécurité renforcée 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 d'object storage qui implémente le protocole Amazon S3. Tout client compatible Amazon S3 peut se connecter à MinIO et interagir sans difficulté avec votre object storage. Une bibliothèque cliente Amazon S3 existe pour quasiment tous les principaux langages de programmation, notamment Ruby, Node.js, Java, Python, Clojure et Erlang.

Nous vous recommandons d'utiliser les SDK MinIO pour vous connecter à votre object storage. Vous trouverez la liste complète des SDK disponibles dans la documentation officielle MinIO.

Vous pouvez également utiliser le MinIO CLI. Cet outil est particulièrement utile pour gérer de gros fichiers directement depuis votre terminal. Un guide détaillé sur l'utilisation du MinIO CLI est disponible dans la documentation officielle du MinIO CLI.

Utilisation du MinIO CLI

Votre instance Stackhero for MinIO inclut par défaut l'interface web MinIO Console. Pour des opérations plus avancées, vous pouvez choisir d'utiliser le MinIO CLI.

La façon la plus simple de tester le MinIO CLI est d'exécuter son conteneur Docker. Suivez ces étapes :

Lancez le conteneur :

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

À l'intérieur du conteneur, ajoutez votre serveur avec la commande suivante (remplacez les valeurs par vos propres identifiants) :
```
mc alias set minio https://<XXXXXX>.stackhero-network.com <ROOT_ACCESS_KEY> <MINIO_ROOT_SECRET_KEY>
```
Créez un bucket nommé "test" pour vérifier la configuration :
```
mc mb minio/test
```
Listez vos buckets :
```
mc ls minio
```

Vous pouvez afficher les autres commandes du MinIO CLI en exécutant mc --help.

Connecter Ruby à MinIO

Commencez par installer la gem AWS SDK :

gem install aws-sdk
bundle install

Voici un exemple simple montrant comment interagir avec MinIO via 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

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

# get_object operation
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.

Connecter Python à MinIO

Il existe deux principales méthodes pour connecter des applications Python à MinIO.

Connexion à MinIO avec l'AWS SDK (boto)

Commencez par installer le package AWS SDK (boto3) :

pip install boto3
pip freeze > requirements.txt

L'exemple suivant montre comment se connecter à MinIO avec 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éverse un fichier local '/home/john/piano.mp3' dans le bucket 'songs' sous le nom 'piano.mp3'
s3.Bucket('songs').upload_file('/home/john/piano.mp3', 'piano.mp3')

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

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

Plus d'informations sont disponibles dans la documentation Python de MinIO.

Connexion à MinIO avec le SDK MinIO

Vous pouvez aussi utiliser le SDK MinIO pour Python. Installez d'abord le package MinIO :

pip install minio
pip freeze > requirements.txt

Voici un exemple de connexion à MinIO avec 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 avec vos clés d'accès et secrète
  client = Minio(
    endpoint='<XXXXXX>.stackhero-network.com:443',
    secure=True,
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
  )

  # Vérifie si le bucket 'asiatrip' existe, et le crée si besoin
  found = client.bucket_exists("asiatrip")
  if not found:
    client.make_bucket("asiatrip")
  else:
    print("Bucket 'asiatrip' already exists")

  # Téléverse '/home/user/Photos/asiaphotos.zip' sous le nom '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 aller plus loin, consultez la documentation du SDK Python MinIO.

Connecter PHP à MinIO

Pour connecter PHP à MinIO, commencez par installer le package AWS SDK for PHP :

composer require aws/aws-sdk-php

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

<?php

// Inclure le SDK via l'autoloader 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'
  ],
]);

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

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

// Affiche le contenu récupéré.
echo $retrieve['Body'];

Connecter Go à MinIO

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

Connexion à MinIO avec l'AWS SDK

Commencez par installer 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 avec 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")

  // Configuration 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ée un nouveau bucket
  _, err := s3Client.CreateBucket(cparams)
  if err != nil {
    fmt.Println(err.Error())
    return
  }

  // Téléverse 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ère l'objet et l'enregistre 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 en savoir plus, consultez 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 de connexion à MinIO avec 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

  // Initialise 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 prêt
}

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

Connecter Node.js à MinIO

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

Connexion à MinIO avec l'AWS SDK

Commencez par installer le package AWS SDK pour Node.js :

npm install aws-sdk

Voici un exemple montrant comment se connecter à MinIO avec 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'
});

// putObject operation
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');
  }
);

// getObject operation
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, consultez 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 avec npm :

npm install minio

Voici un exemple de connexion à MinIO avec 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éverser
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éverse le fichier dans le bucket 'europetrip' avec 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 MinIO.