Libraries verwenden

Last change on 2025-06-05 • 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, Go und C#.

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

C#



Für Python

AWS SDK für Python Boto3

offizielle Dokumentation

import logging
import random
import string
from boto3 import client
from botocore.client import Config

# 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",
    config=Config(
        signature_version='s3v4',
        s3={
            'payload_signing_enabled': False,
            'addressing_style': 'virtual',
        },
    )
)

# 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")
}

Für C#

AWS SDK für .NET

offizielle Dokumentation

using Amazon.S3;
using Amazon.S3.Model;

const string accessKey = "YOUR_ACCESS_KEY";
const string secretKey = "YOUR_SECRET_KEY";

// Zufälligen Bucket-Namen erzeugen.
var bucketName = $"my-bucket-{Guid.NewGuid()}";

// Einen neuen S3-Client erstellen.
var config = new AmazonS3Config
{
    ServiceURL = "https://fsn1.your-objectstorage.com",
    AuthenticationRegion = "fsn1",
    ForcePathStyle = false
};
var client = new AmazonS3Client(accessKey, secretKey, config);

// Einen neuen Bucket erstellen.
var createBucket = new PutBucketRequest
{
    BucketName = bucketName,
    BucketRegionName = "fsn1"
};
await client.PutBucketAsync(createBucket);
Console.WriteLine($"Created bucket: {bucketName}");

// Ein kleines Objekt hochladen.
var createObject = new PutObjectRequest
{
    BucketName = bucketName,
    Key = "my-object",
    ContentBody = """
                  # My object

                  This markdown document is the content of my object.
                  """
};
await client.PutObjectAsync(createObject);
Console.WriteLine("Created object.");
Table of Contents