Libraries verwenden

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

Im Allgemeinen sollten alle AWS SDKs gut mit unserem Object Storage funktionieren. Im Folgenden findest du ein paar Beispiele für Python, Go und C#.

Beachte, 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