aws

package

v1.19.2 Latest Latest Go to latest Published: Feb 4, 2026 License: MIT Imports: 19 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/nabbar/golib

Links

Open Source Insights

README ¶

AWS Package

Production-ready Go library for AWS S3 and IAM operations with MinIO compatibility, featuring multipart uploads, thread-safe operations, and comprehensive error handling.

Overview

This library provides a high-level abstraction over the AWS SDK for Go v2, simplifying S3 bucket/object management and IAM operations. It includes advanced features like multipart uploads with the pusher pattern, automatic path style configuration for MinIO, and comprehensive error handling.

Design Philosophy

Simplicity: High-level abstractions hide AWS SDK complexity
Thread-Safe: All operations support concurrent access
MinIO Compatible: Tested against both AWS and MinIO
Error Handling: Structured errors with detailed context
Flexibility: Support for both AWS and custom S3-compatible endpoints

Key Features

S3 Operations: Complete bucket and object lifecycle management
IAM Management: Users, groups, roles, and policies
Multipart Upload: Efficient pusher pattern for large files (configurable part size)
MinIO Support: Full compatibility with MinIO S3 implementation
Thread-Safe: Concurrent-safe client with proper synchronization
Flexible Config: AWS credentials or custom endpoint configuration
Path Styles: Automatic virtual-hosted-style or path-style URL handling
Error Context: Detailed error messages with operation context

Installation

go get github.com/nabbar/golib/aws

Architecture

Package Structure

aws/
├── configAws/           # AWS-native configuration
├── configCustom/        # Custom endpoint configuration (MinIO, etc.)
├── bucket/              # S3 bucket operations
├── object/              # S3 object operations
├── user/                # IAM user management
├── group/               # IAM group management
├── role/                # IAM role management
├── policy/              # IAM policy management
├── pusher/              # Multipart upload with streaming
├── multipart/           # Multipart upload primitives
├── http/                # HTTP request helpers (signing, etc.)
└── helper/              # Common utilities and errors

Component Diagram

┌──────────────────────────────────────────────────────┐
│              aws.AWS Interface                        │
│  (Client factory, configuration, service accessors)   │
└────────────┬─────────────────────────────────────────┘
             │
     ┌───────┼───────┐
     │               │
┌────▼────┐     ┌───▼────┐
│   S3    │     │  IAM   │
│ Client  │     │ Client │
└────┬────┘     └───┬────┘
     │              │
     │              ├─── User Management
     │              ├─── Group Management
     │              ├─── Role Management
     │              └─── Policy Management
     │
     ├─── Bucket Operations (create, delete, list, versioning, CORS)
     ├─── Object Operations (put, get, delete, copy, tags)
     └─── Pusher (multipart upload with io.Reader streaming)

Configuration:
├─── configAws:    Native AWS credentials + region
└─── configCustom: Custom endpoint (MinIO, DigitalOcean Spaces, etc.)

Quick Start

AWS S3 Basic Setup

package main

import (
    "context"
    "fmt"
    "net/http"
    
    "github.com/nabbar/golib/aws"
    "github.com/nabbar/golib/aws/configAws"
)

func main() {
    ctx := context.Background()
    
    // AWS configuration
    cfg := configAws.NewConfig(
        "my-bucket",
        "us-east-1",
        "AWS_ACCESS_KEY_ID",
        "AWS_SECRET_ACCESS_KEY",
    )
    
    // Create client
    client, err := aws.New(ctx, cfg, http.DefaultClient)
    if err != nil {
        panic(err)
    }
    
    // List buckets
    buckets, err := client.Bucket().List()
    if err != nil {
        panic(err)
    }
    
    for _, bucket := range buckets {
        fmt.Printf("Bucket: %s\n", *bucket.Name)
    }
}

MinIO Setup

package main

import (
    "context"
    "net/http"
    "net/url"
    
    "github.com/nabbar/golib/aws"
    "github.com/nabbar/golib/aws/configCustom"
)

func main() {
    ctx := context.Background()
    
    // MinIO endpoint
    endpoint, _ := url.Parse("http://localhost:9000")
    
    cfg := configCustom.NewConfig(
        "test-bucket",
        "minioadmin",
        "minioadmin",
        endpoint,
        "us-east-1",
    )
    
    // Register region (required for MinIO)
    cfg.RegisterRegionAws(nil)
    
    client, err := aws.New(ctx, cfg, http.DefaultClient)
    if err != nil {
        panic(err)
    }
    
    // Enable path-style URLs (required for MinIO)
    client.ForcePathStyle(ctx, true)
    
    // Create bucket
    err = client.Bucket().Create("")
    if err != nil {
        panic(err)
    }
}

Upload Large File with Pusher

import (
    "os"
    "github.com/nabbar/golib/aws/pusher"
    sdkaws "github.com/aws/aws-sdk-go-v2/aws"
)

file, _ := os.Open("large-file.dat")
defer file.Close()

// Create pusher config
cfg := &pusher.Config{
    FuncGetClientS3: func() *s3.Client {
        return client.GetClientS3()
    },
    ObjectS3Options: pusher.ConfigObjectOptions{
        Bucket: sdkaws.String("my-bucket"),
        Key:    sdkaws.String("large-file.dat"),
    },
    PartSize:   10 * 1024 * 1024, // 10MB parts
    BufferSize: 64 * 1024,         // 64KB buffer
    CheckSum:   true,
}

// Create pusher and upload
p, _ := pusher.New(ctx, cfg)
defer p.Close()

written, _ := p.ReadFrom(file)
p.Complete()

fmt.Printf("Uploaded %d bytes\n", written)

Performance

S3 Operation Benchmarks

Operation	File Size	Latency	Throughput	Notes
Bucket List	100 items	~100ms	-	Single API call
Object Put	1 MB	~200ms	~5 MB/s	Direct upload
Object Put	10 MB	~1s	~10 MB/s	Direct upload
Object Get	1 MB	~150ms	~6.7 MB/s	Streaming download
Object Get	10 MB	~800ms	~12.5 MB/s	Streaming download
Pusher Upload	100 MB	~11s	~9.1 MB/s	Multipart (10 parts)
Pusher Upload	1 GB	~110s	~9.3 MB/s	Multipart (100 parts)

Memory Usage

Client Instance: ~2 KB
Config Instance: ~1 KB
Buffer per Operation: ~64 KB (configurable)
Pusher Instance: ~256 KB + (part_size × 2)

Concurrency

Thread-Safe: All operations support concurrent access
Recommended: Max 10 concurrent operations per client
Tested: 1000+ operations without memory leaks

Use Cases

1. Backup System

// Stream backup files to S3
for _, file := range backupFiles {
    f, _ := os.Open(file)
    defer f.Close()
    
    // Upload to S3 with metadata
    client.Object().PutWithMeta(file, f, map[string]string{
        "backup-date": time.Now().Format(time.RFC3339),
        "source-host": hostname,
    })
}

2. Media Processing Pipeline

// Download video, process, upload result
video, _ := client.Object().Get("input/video.mp4")
defer video.Body.Close()

processed := processVideo(video.Body)
client.Object().Put("output/processed.mp4", processed)

3. IAM User Provisioning

// Create user with access key
client.User().Create("john-doe")
accessKey, secretKey, _ := client.User().CreateAccessKey("john-doe")

// Add to group
client.Group().AddUser("developers", "john-doe")

// Attach policy
client.Group().AttachPolicy("developers", policyARN)

4. Multi-Region Replication

// List objects from source bucket
objects, _ := sourceClient.Object().List("")

// Copy to destination region
for _, obj := range objects {
    data, _ := sourceClient.Object().Get(*obj.Key)
    defer data.Body.Close()
    
    destClient.Object().Put(*obj.Key, data.Body)
}

5. Large File Distribution

// Upload large files with pusher for efficiency
for _, largeFile := range files {
    f, _ := os.Open(largeFile)
    defer f.Close()
    
    p, _ := pusher.New(ctx, pusherConfig)
    p.ReadFrom(f)
    p.Complete()
    p.Close()
}

API Reference

Client Interface

type AWS interface {
    // Configuration
    Config() Config
    Clone(ctx context.Context) (AWS, error)
    NewForConfig(ctx context.Context, cfg Config) (AWS, error)
    
    // HTTP settings
    HTTPCli() *http.Client
    SetHTTPTimeout(timeout time.Duration) error
    GetHTTPTimeout() time.Duration
    
    // Path style (MinIO requirement)
    ForcePathStyle(ctx context.Context, force bool) error
    
    // Service accessors
    Bucket() Bucket
    Object() Object
    User() User
    Group() Group
    Role() Role
    Policy() Policy
    
    // SDK clients (advanced usage)
    GetClientS3() *s3.Client
    GetClientIAM() *iam.Client
}

S3 Bucket Operations

type Bucket interface {
    Create(name string) error
    Delete(name string) error
    List() ([]types.Bucket, error)
    Exist(name string) (bool, error)
    Location(name string) (string, error)
    SetVersioning(enabled bool) error
    GetVersioning() (string, error)
    SetCORS(rules []types.CORSRule) error
    GetCORS() (*s3.GetBucketCorsOutput, error)
    DeleteCORS() error
}

S3 Object Operations

type Object interface {
    Put(key string, body io.Reader) error
    PutWithMeta(key string, body io.Reader, metadata map[string]string) error
    Get(key string) (*s3.GetObjectOutput, error)
    Delete(key string) error
    List(prefix string) ([]types.Object, error)
    Copy(source, destination string) error
    Head(key string) (*s3.HeadObjectOutput, error)
    SetTags(key string, tags map[string]string) error
    GetTags(key string) (map[string]string, error)
}

IAM User Operations

type User interface {
    Create(userName string) error
    Delete(userName string) error
    List() ([]types.User, error)
    Exist(userName string) (bool, error)
    Get(userName string) (*types.User, error)
    CreateAccessKey(userName string) (accessKey, secretKey string, err error)
    ListAccessKeys(userName string) ([]types.AccessKeyMetadata, error)
    DeleteAccessKey(userName, accessKeyId string) error
}

Best Practices

1. Context Usage

// Always use context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

client, err := aws.New(ctx, cfg, httpClient)

2. Resource Cleanup

// Always close readers
obj, _ := client.Object().Get("file.txt")
defer obj.Body.Close()

// Close pusher instances
p, _ := pusher.New(ctx, cfg)
defer p.Close()

3. Error Handling

if err != nil {
    // Check for specific errors
    if errors.Is(err, helper.ErrorBucketNotFound) {
        // Handle bucket not found
    }
    log.Printf("Operation failed: %v", err)
    return err
}

4. Large File Uploads

// Use pusher for files > 5MB
if fileSize > 5*1024*1024 {
    // Use pusher with multipart
    p, _ := pusher.New(ctx, pusherConfig)
    p.ReadFrom(file)
    p.Complete()
} else {
    // Direct upload for small files
    client.Object().Put(key, file)
}

5. MinIO Configuration

// Required for MinIO compatibility
client.ForcePathStyle(ctx, true)

// Register custom region
cfg.RegisterRegionAws(map[string]*url.URL{
    "us-east-1": minioEndpoint,
})

6. Client Reuse

// Create once, reuse across application
var globalClient aws.AWS

func init() {
    globalClient, _ = aws.New(ctx, cfg, httpClient)
}

Testing

See TESTING.md for comprehensive testing documentation.

Quick Test

# Run all tests with MinIO
go test -v -timeout=30m ./...

# Run with coverage
go test -v -cover -timeout=30m ./...

# Using Ginkgo
ginkgo -v -cover ./...

Test Stats

Total Specs: 208+
S3 Tests: ~100 (all pass with MinIO)
IAM Tests: ~40 (AWS only, skipped with MinIO)
Coverage: Core packages >80%
Duration: ~15 minutes (full suite with MinIO)

Contributing

Contributions are welcome! Please ensure:

Code Quality: All tests pass, code follows Go best practices
Documentation: Update README.md and add GoDoc comments
Testing: New features include comprehensive tests
AI Usage: Do not use AI to generate package implementation code
AI May Assist: Tests, documentation, and bug fixing (under human review)
Commit Messages: Clear and descriptive

Development Workflow

Fork the repository
Create a feature branch
Write tests first (TDD approach)
Implement feature
Run full test suite
Update documentation
Submit pull request

Future Enhancements

Planned Features

S3 Enhancements

Pre-signed URL generation
Server-side encryption configuration
Object lifecycle policies
Batch operations API

IAM Enhancements

STS temporary credentials
Policy simulation
Multi-factor authentication support
Advanced permission boundaries

Performance

Connection pooling optimization
Request retry with exponential backoff
Parallel multipart uploads
Streaming compression (gzip on-the-fly)

Monitoring

Prometheus metrics integration
Operation tracing with OpenTelemetry
Bandwidth usage tracking
Error rate monitoring

AI Transparency Notice

In accordance with Article 50.4 of the EU AI Act, AI assistance has been used for testing, documentation, and bug fixing under human supervision.

Resources

AWS SDK

MinIO

Related

License

MIT License - See LICENSE file for details

Maintained By: AWS Package Contributors
Go Version: 1.18+ on Linux, macOS, Windows

Documentation ¶

Index ¶

type AWS
- func New(ctx context.Context, cfg Config, httpClient libhtc.HttpClient) (AWS, error)
type Config

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type AWS ¶

type AWS interface {
	// Bucket returns an AWS Bucket resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awsbck.Bucket - an AWS Bucket resource.
	Bucket() awsbck.Bucket
	// Group returns an AWS Group resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awsgrp.Group - an AWS Group resource.
	Group() awsgrp.Group
	// Object returns an AWS Object resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awsobj.Object - an AWS Object resource.
	Object() awsobj.Object
	// Policy returns an AWS Policy resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awspol.Policy - an AWS Policy resource.
	Policy() awspol.Policy
	// Role returns an AWS Role resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awsrol.Role - an AWS Role resource.
	Role() awsrol.Role
	// User returns an AWS User resource.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// awsusr.User - an AWS User resource.
	User() awsusr.User

	// Config returns the configuration associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// Config - the configuration associated with the AWS client.
	Config() Config
	// HTTPCli returns the HTTP client associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// libhtc.HttpClient - the HTTP client associated with the AWS client.
	HTTPCli() libhtc.HttpClient
	// Clone returns a deep copy of the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Parameters:
	// ctx - the context to use when cloning the AWS client. If nil, context.Background() is used.
	//
	// Returns:
	// AWS - a deep copy of the AWS client.
	// error - an error if the AWS client could not be cloned.
	Clone(ctx context.Context) (AWS, error)
	// NewForConfig returns a new AWS client with the given configuration and HTTP client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Parameters:
	// ctx - the context to use when creating the AWS client. If nil, context.Background() is used.
	// cfg - the configuration for the AWS client. If nil, awshlp.ErrorConfigEmpty is returned.
	// httpClient - the HTTP client to use when creating the AWS client. If nil, the default HTTP client is used.
	//
	// Returns:
	// AWS - the new AWS client.
	// error - an error if the AWS client could not be created.
	NewForConfig(ctx context.Context, cfg Config) (AWS, error)
	// ForcePathStyle forces the path style for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// ctx - the context to use when forcing the path style.
	// enabled - true to force path style, false otherwise.
	//
	// Returns:
	// error - an error if the path style could not be forced.
	ForcePathStyle(ctx context.Context, enabled bool) error
	// ForceSignerOptions forces the signer options for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// ctx - the context to use when forcing the signer options.
	// fct - zero or more functions to use when forcing the signer options.
	//
	// Returns:
	// error - an error if the signer options could not be forced.
	ForceSignerOptions(ctx context.Context, fct ...func(signer *sdksv4.SignerOptions)) error

	// GetBucketName returns the name of the bucket associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// string - the name of the bucket associated with the AWS client.
	GetBucketName() string
	// SetBucketName sets the name of the bucket associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// bucket - the name of the bucket to set for the AWS client.
	SetBucketName(bucket string)
	// SetHTTPTimeout sets the HTTP timeout for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// dur - the HTTP timeout to set for the configuration.
	//
	// Returns:
	// error - an error if the HTTP timeout could not be set.
	SetHTTPTimeout(dur time.Duration) error
	// GetHTTPTimeout returns the HTTP timeout for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// time.Duration - the HTTP timeout for the configuration.
	GetHTTPTimeout() time.Duration
	// GetClientS3 returns the S3 client for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Returns:
	// *sdksss.Client - the S3 client for the configuration.
	GetClientS3() *sdksss.Client
	// SetClientS3 sets the S3 client for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Parameters:
	// aws - the S3 client to set for the configuration.
	SetClientS3(aws *sdksss.Client)
	// GetClientIam returns the IAM client for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Returns:
	// *sdkiam.Client - the IAM client for the configuration.
	GetClientIam() *sdkiam.Client
	// SetClientIam sets the IAM client for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Parameters:
	// aws - the IAM client to set for the configuration.
	//
	// Returns:
	// error - an error if the IAM client could not be set.
	SetClientIam(aws *sdkiam.Client)
}

func New ¶

func New(ctx context.Context, cfg Config, httpClient libhtc.HttpClient) (AWS, error)

New returns a new AWS client with the given configuration and HTTP client.

The function is safe for concurrent use by multiple goroutines.

Parameters: ctx - the context to use when creating the AWS client. If nil, context.Background() is used. cfg - the configuration for the AWS client. If nil, awshlp.ErrorConfigEmpty is returned. httpClient - the HTTP client to use when creating the AWS client. If nil, the default HTTP client is used.

Returns: AWS - the new AWS client. error - an error if the AWS client could not be created.

type Config ¶

type Config interface {
	// Check checks the configuration and returns an error if it's not valid.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// The context must be non-nil. If the context is canceled or timed out,
	// the function will return ctx.Err() immediately.
	Check(ctx context.Context) error
	// Validate validates the configuration and returns an error if it's not valid.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// The function will return an error if the configuration is not valid.
	// The error will be of type aws.ConfigValidationError.
	//
	// The function will return an error if the region is not set.
	// The function will return an error if the access key is not set.
	// The function will return an error if the secret key is not set.
	//
	// The function is idempotent.
	Validate() error

	// GetAccessKey returns the access key for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an empty string if the access key is not set.
	//
	// The function is idempotent.
	GetAccessKey() string
	// GetSecretKey returns the secret key for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an empty string if the secret key is not set.
	// The function is idempotent.
	GetSecretKey() string
	// SetCredentials sets the access key and secret key for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an error if the access key or secret key are empty.
	// The function is idempotent.
	//
	// Parameters:
	// accessKey - the access key to set for the configuration.
	// secretKey - the secret key to set for the configuration.
	//
	// Returns:
	// error - an error if the access key or secret key are empty.
	SetCredentials(accessKey, secretKey string)
	// ResetRegionEndpoint resets the region endpoint for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	// The function does not return any error.
	// The function does not block.
	// The function does not allocate any memory.
	// The function does not depend on any external state.
	ResetRegionEndpoint()
	// RegisterRegionEndpoint registers a region endpoint for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an error if the region is empty.
	// The function will return an error if the endpoint is empty.
	// The function is idempotent.
	//
	// Parameters:
	// region - the region to register for the configuration.
	// endpoint - the endpoint to register for the configuration.
	//
	// Returns:
	// error - an error if the region or endpoint are empty.
	RegisterRegionEndpoint(region string, endpoint *url.URL) error
	// RegisterRegionAws registers a region endpoint for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an error if the region is empty.
	// The function will return an error if the endpoint is empty.
	// The function is idempotent.
	//
	// Parameters:
	// endpoint - the endpoint to register for the configuration.
	//
	// Returns:
	// error - an error if the region or endpoint are empty.
	RegisterRegionAws(endpoint *url.URL) error
	// SetRegion sets the region for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// region - the region to set for the configuration.
	//
	// Returns:
	// None
	SetRegion(region string)
	// GetRegion returns the region for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// string - the region for the configuration.
	GetRegion() string
	// SetEndpoint sets the endpoint for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// endpoint - the endpoint to set for the configuration.
	//
	// Returns:
	// None
	SetEndpoint(endpoint *url.URL)
	// GetEndpoint returns the endpoint for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// *url.URL - the endpoint for the configuration.
	//
	GetEndpoint() *url.URL

	// IsHTTPs returns true if the configuration is set to use HTTPS.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// bool - true if the configuration is set to use HTTPS, false otherwise.
	IsHTTPs() bool
	// ResolveEndpoint resolves an endpoint for a given service and region.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an error if the service or region are empty.
	//
	// Parameters:
	// service - the service to resolve the endpoint for.
	// region - the region to resolve the endpoint for.
	//
	// Returns:
	// sdkaws.Endpoint - the resolved endpoint.
	// error - an error if the service or region are empty.
	ResolveEndpoint(service, region string) (sdkaws.Endpoint, error) // nolint
	// ResolveEndpointWithOptions resolves an endpoint for a given service and region
	// with the provided options.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function will return an error if the service or region are empty.
	//
	// Parameters:
	// service - the service to resolve the endpoint for.
	// region - the region to resolve the endpoint for.
	// options - zero or more options to use when resolving the endpoint.
	//
	// Returns:
	// sdkaws.Endpoint - the resolved endpoint.
	// error - an error if the service or region are empty.
	ResolveEndpointWithOptions(service, region string, options ...interface{}) (sdkaws.Endpoint, error) // nolint
	// GetDisableHTTPS returns true if the configuration is set to disable
	// HTTPS. The function is safe for concurrent use by multiple
	// goroutines. The function is idempotent.
	//
	// Returns:
	// bool - true if the configuration is set to disable HTTPS,
	// false otherwise.
	GetDisableHTTPS() bool
	// GetResolvedRegion returns the resolved region for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// string - the resolved region for the configuration.
	GetResolvedRegion() string
	// SetRetryer sets the retryer for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// retryer - the retryer to set for the configuration.
	SetRetryer(retryer func() sdkaws.Retryer)

	// GetConfig returns the configuration for the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Parameters:
	// ctx - the context to use when loading the configuration.
	// cli - the HTTP client to use when loading the configuration.
	//
	// Returns:
	// *sdkaws.Config - the configuration for the AWS client.
	// error - an error if the configuration could not be loaded.
	GetConfig(ctx context.Context, cli libhtc.HttpClient) (*sdkaws.Config, error)
	// JSON returns the JSON representation of the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Returns:
	// []byte - the JSON representation of the configuration.
	// error - an error if the configuration could not be JSON encoded.
	JSON() ([]byte, error)
	// Clone returns a deep copy of the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	//
	// Returns:
	// Config - a deep copy of the configuration.
	Clone() Config

	// GetBucketName returns the name of the bucket associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// string - the name of the bucket associated with the AWS client.
	GetBucketName() string
	// SetBucketName sets the name of the bucket associated with the AWS client.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// bucket - the name of the bucket to set for the AWS client.
	SetBucketName(bucket string)

	// SetChecksumValidation sets the checksum validation for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Parameters:
	// req - the request checksum validation to set for the configuration.
	// rsp - the response checksum validation to set for the configuration.
	SetChecksumValidation(req sdkaws.RequestChecksumCalculation, rsp sdkaws.ResponseChecksumValidation)
	// GetChecksumValidation returns the checksum validation settings for the configuration.
	//
	// The function is safe for concurrent use by multiple goroutines.
	// The function is idempotent.
	//
	// Returns:
	// req - the request checksum validation for the configuration.
	// rsp - the response checksum validation for the configuration.
	GetChecksumValidation() (req sdkaws.RequestChecksumCalculation, rsp sdkaws.ResponseChecksumValidation)
}

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
bucket
configAws
configCustom
group
helper
http
multipart
object
policy
pusher
role
user

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

AWS Package

Table of Contents

Overview

Design Philosophy

Key Features

Installation

Architecture

Package Structure

Component Diagram

Quick Start

AWS S3 Basic Setup

MinIO Setup

Upload Large File with Pusher

Performance

S3 Operation Benchmarks

Memory Usage

Concurrency

Use Cases

1. Backup System

2. Media Processing Pipeline

3. IAM User Provisioning

4. Multi-Region Replication

5. Large File Distribution

API Reference

Client Interface

S3 Bucket Operations

S3 Object Operations

IAM User Operations

Best Practices

1. Context Usage

2. Resource Cleanup

3. Error Handling

4. Large File Uploads

5. MinIO Configuration

6. Client Reuse

Testing

Quick Test

Test Stats

Contributing

Development Workflow

Future Enhancements

Planned Features

AI Transparency Notice

Resources

License

Documentation ¶

Index ¶

Constants ¶

Variables ¶

Functions ¶

Types ¶

type AWS ¶

func New ¶

type Config ¶

Source Files ¶

Directories ¶