Libraries verwenden

Last change on 2024-12-03 • Created on 2024-11-20 • ID: ST-CAE3E

Im Allgemeinen sollten alle AWS SDKs gut mit unserem Object Storage funktionieren. Im Folgenden finden Sie ein paar Beispiele für Python und Go.

Beachten Sie, dass diese Beispiele nur zur Einstiegshilfe gedacht sind. Wir können jedoch nicht garantieren, dass alles uneingeschränkt funktioniert, und bieten dafür KEINEN Support an.

Der Artikel enthält die folgenden Beispiele:

Python

Go



Für Python

AWS SDK für Python Boto3

offizielle Dokumentation

import logging
import random
import string
from boto3 import client

# Zufällige Zeichenfolge generieren
def random_hash(length=8):
    return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))

# Bucket-Namen mit zufälliger Zeichenfolge als Variable festlegen
VAR_BUCKET_NAME = f"my-bucket-{random_hash()}"

# Einen neuen S3-Client erstellen
s3 = client(
    "s3",
    region_name="fsn1",
    endpoint_url="https://fsn1.your-objectstorage.com",
    aws_access_key_id="YOUR_ACCESS_KEY",
    aws_secret_access_key="YOUR_SECRET_KEY",
)

# Einen neuen Bucket erstellen
s3.create_bucket(Bucket=VAR_BUCKET_NAME)

logging.info(f"created Bucket: {VAR_BUCKET_NAME}")

# Ein kleines Objekt hochladen
s3.put_object(
    Bucket=VAR_BUCKET_NAME,
    Key="my-object",
    Body="""
# Mein Objekt

Dieser Markdown-Text ist der Inhalt meines Objekts.
""",
)

logging.info("created object")

Für Go

MinIO Go Client SDK

offizielle Dokumentation

package main

import (
        "context"
        "crypto/rand"
        "encoding/hex"
        "fmt"
        "log"
        "strings"

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

// Zufällige Zeichenfolge generieren
func generateRandomHash(length int) string {
        bytes := make([]byte, length)
        _, err := rand.Read(bytes)
        if err != nil {
                log.Fatalf("Failed to generate random hash: %v", err)
        }
        return hex.EncodeToString(bytes)[:length]
}

func main() {
        ctx := context.Background()

        // Bucket-Namen mit zufälliger Zeichenfolge als Variable festlegen
        VAR_BUCKET_NAME := fmt.Sprintf("my-bucket-%s", generateRandomHash(8))

        // Einen neuen S3-Client erstellen
        client, err := minio.New("fsn1.your-objectstorage.com", &minio.Options{
                Secure: true,
                Creds: credentials.NewStaticV4(
                        "YOUR-ACCESS-KEY",
                        "YOUR-SECRET-KEY",
                        "",
                ),
        })
        if err != nil {
                log.Fatal(err)
        }

        // Einen neuen Bucket erstellen
        err = client.MakeBucket(ctx, VAR_BUCKET_NAME, minio.MakeBucketOptions{Region: "fsn1"})
        if err != nil {
                log.Fatal(err)
        }

        log.Printf("Created Bucket: %s", VAR_BUCKET_NAME)

        // Ein kleines Objekt hochladen
        body := strings.NewReader(strings.TrimSpace(`
# Mein Objekt

Dieser Markdown-Text ist der Inhalt meines Objekts.
`))

        _, err = client.PutObject(ctx,
                VAR_BUCKET_NAME,
                "my-object",
                body,
                body.Size(),
                minio.PutObjectOptions{},
        )
        if err != nil {
                log.Fatal(err)
        }

        log.Println("Created object")
}

AWS SDK für Go v2

offizielle Dokumentation

package main

import (
    "context"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "log"
    "strings"

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

// Zufällige Zeichenfolge generieren
func generateRandomHash(length int) string {
        bytes := make([]byte, length)
        _, err := rand.Read(bytes)
        if err != nil {
                log.Fatalf("Failed to generate random hash: %v", err)
        }
        return hex.EncodeToString(bytes)[:length]
}

func main() {
    ctx := context.Background()

    // Bucket-Namen mit zufälliger Zeichenfolge als Variable festlegen
    VAR_BUCKET_NAME := fmt.Sprintf("my-bucket-%s", generateRandomHash(8))

    // Einen neuen S3-Client erstellen
    client := s3.New(s3.Options{
        AppID: "my-application/0.0.1",

        Region:       "fsn1",
        BaseEndpoint: aws.String("https://fsn1.your-objectstorage.com"),

        Credentials: credentials.StaticCredentialsProvider{Value: aws.Credentials{
            AccessKeyID:     "YOUR-ACCESS-KEY",
            SecretAccessKey: "YOUR-SECRET-KEY",
        }},
    })

    // Einen neuen Bucket erstellen
    _, err := client.CreateBucket(ctx, &s3.CreateBucketInput{
        Bucket: aws.String(VAR_BUCKET_NAME),
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Created Bucket: %s", VAR_BUCKET_NAME)

    // Ein kleines Objekt hochladen
    body := strings.NewReader(strings.TrimSpace(`
# Mein Objekt

Dieser Markdown-Text ist der Inhalt meines Objekts.
`))

    _, err = client.PutObject(ctx, &s3.PutObjectInput{
        Bucket:      aws.String(VAR_BUCKET_NAME),
        Key:         aws.String("my-object-e9be8f5c"),
        ContentType: aws.String("text/markdown"),

        Body: body,
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Println("Created object")
}
Table of Contents