S3 Quickstart

import boto3
from boto3.s3.transfer import TransferConfig
from botocore.config import Config

# Prefer environment variables or a secrets store over hard-coded keys
s3 = boto3.client(
    "s3",
    endpoint_url="https://s3.ironshard.ai",
    aws_access_key_id="IRONSHARD_ACCESS_KEY",
    aws_secret_access_key="IRONSHARD_SECRET_KEY",
    config=Config(
        signature_version="s3v4",
        s3={"addressing_style": "path"},  # required: path-style bucket addressing
    ),
)

# Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
s3.create_bucket(
    Bucket="my-new-bucket",
    CreateBucketConfiguration={"LocationConstraint": "STORAGE_POLICY_NAME"},
)

# List the objects in a bucket
for obj in s3.list_objects_v2(Bucket="my-new-bucket").get("Contents", []):
    print(obj["Key"])

# 32 MB multipart parts give the fastest transfers
MB = 1024 * 1024
transfer = TransferConfig(multipart_threshold=32 * MB, multipart_chunksize=32 * MB)
s3.upload_file("local-file.bin", "my-new-bucket", "remote-file.bin", Config=transfer)

import { S3Client, CreateBucketCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";

// Prefer environment variables or a secrets store over hard-coded keys
const s3 = new S3Client({
  endpoint: "https://s3.ironshard.ai",
  region: "us-east-1", // required by the SDK for request signing, any value works
  forcePathStyle: true, // required: path-style bucket addressing
  credentials: {
    accessKeyId: "IRONSHARD_ACCESS_KEY",
    secretAccessKey: "IRONSHARD_SECRET_KEY",
  },
});

// Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
await s3.send(new CreateBucketCommand({
  Bucket: "my-new-bucket",
  CreateBucketConfiguration: { LocationConstraint: "STORAGE_POLICY_NAME" },
}));

// List the objects in a bucket
const { Contents = [] } = await s3.send(new ListObjectsV2Command({ Bucket: "my-new-bucket" }));
console.log(Contents.map((o) => o.Key));

package main

import (
    "context"
    "fmt"

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

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

    // Prefer environment variables or a secrets store over hard-coded keys
    cfg, err := config.LoadDefaultConfig(ctx,
        config.WithRegion("us-east-1"), // required by the SDK for request signing, any value works
        config.WithCredentialsProvider(
            credentials.NewStaticCredentialsProvider("IRONSHARD_ACCESS_KEY", "IRONSHARD_SECRET_KEY", ""),
        ),
    )
    if err != nil {
        panic(err)
    }

    client := s3.NewFromConfig(cfg, func(o *s3.Options) {
        o.BaseEndpoint = aws.String("https://s3.ironshard.ai")
        o.UsePathStyle = true // required: path-style bucket addressing
    })

    // Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
    _, err = client.CreateBucket(ctx, &s3.CreateBucketInput{
        Bucket: aws.String("my-new-bucket"),
        CreateBucketConfiguration: &types.CreateBucketConfiguration{
            LocationConstraint: types.BucketLocationConstraint("STORAGE_POLICY_NAME"),
        },
    })
    if err != nil {
        panic(err)
    }

    // List the objects in a bucket
    out, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String("my-new-bucket")})
    if err != nil {
        panic(err)
    }
    for _, o := range out.Contents {
        fmt.Println(*o.Key)
    }
}

import java.net.URI;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

public class Example {
    public static void main(String[] args) {
        // Prefer environment variables or a secrets store over hard-coded keys
        S3Client s3 = S3Client.builder()
            .endpointOverride(URI.create("https://s3.ironshard.ai"))
            .region(Region.of("us-east-1")) // required by the SDK for request signing, any value works
            .forcePathStyle(true) // required: path-style bucket addressing
            .credentialsProvider(StaticCredentialsProvider.create(
                AwsBasicCredentials.create("IRONSHARD_ACCESS_KEY", "IRONSHARD_SECRET_KEY")))
            .build();

        // Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
        s3.createBucket(b -> b
            .bucket("my-new-bucket")
            .createBucketConfiguration(c -> c.locationConstraint("STORAGE_POLICY_NAME")));

        // List the objects in a bucket
        s3.listObjectsV2(b -> b.bucket("my-new-bucket")).contents()
            .forEach(o -> System.out.println(o.key()));
    }
}

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

// Prefer environment variables or a secrets store over hard-coded keys
var config = new AmazonS3Config
{
    ServiceURL = "https://s3.ironshard.ai",
    ForcePathStyle = true, // required: path-style bucket addressing
};
var s3 = new AmazonS3Client("IRONSHARD_ACCESS_KEY", "IRONSHARD_SECRET_KEY", config);

// Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
await s3.PutBucketAsync(new PutBucketRequest
{
    BucketName = "my-new-bucket",
    BucketRegionName = "STORAGE_POLICY_NAME",
});

// List the objects in a bucket
var response = await s3.ListObjectsV2Async(new ListObjectsV2Request { BucketName = "my-new-bucket" });
foreach (var obj in response.S3Objects ?? []) // null when the bucket is empty
{
    Console.WriteLine(obj.Key);
}

<?php
require 'vendor/autoload.php';

use Aws\S3\S3Client;

// Prefer environment variables or a secrets store over hard-coded keys
$s3 = new S3Client([
    'version' => 'latest',
    'region' => 'us-east-1', // required by the SDK for request signing, any value works
    'endpoint' => 'https://s3.ironshard.ai',
    'use_path_style_endpoint' => true, // required: path-style bucket addressing
    'credentials' => [
        'key' => 'IRONSHARD_ACCESS_KEY',
        'secret' => 'IRONSHARD_SECRET_KEY',
    ],
]);

// Create a bucket with the selected Storage Policy (the access key must be allowed to create buckets)
$s3->createBucket([
    'Bucket' => 'my-new-bucket',
    'CreateBucketConfiguration' => ['LocationConstraint' => 'STORAGE_POLICY_NAME'],
]);

// List the objects in a bucket
foreach ($s3->listObjectsV2(['Bucket' => 'my-new-bucket'])['Contents'] ?? [] as $object) {
    echo $object['Key'] . PHP_EOL;
}