rclone copy s3-source:source-bucket-name stook-target:target-bucket-name

rclone copy s3-source:source-bucket-name/path/to/source-data \
stook-target:target-bucket-name/path/to/target-location

rclone copy --progress s3-source:source-bucket-name stook-target:target-bucket-name

rclone check s3-source:source-bucket-name stook-target:target-bucket-name

require 'vendor/autoload.php';

use Aws\S3\S3Client;  
use Aws\S3\Exception\S3Exception;

$bucket = "bucket";  
$key = "mykey";  

// Create a S3Client  
$s3 = new Aws\S3\S3Client([
    'endpoint' => 'https://customername.mncdn.com',
    'profile' => 'medianova',
    'version' => 'latest',
    'region' => 'us-east-1',
    'use_path_style_endpoint' => true
]);

$cmd = $s3->getCommand('GetObject', [
    'Bucket' => $bucket,
    'Key'    => $key,
]);

$request = $s3->createPresignedRequest($cmd, '+20 minutes');  

$presignedUrl = (string) $request->getUri();  
echo $presignedUrl;

<?php
require 'aws/aws-autoloader.php';

$s3 = new Aws\S3\S3Client([
    'version' => 'latest',
    'region'  => 'us-east-1',
    'endpoint' => 'Enter server info',
    'use_path_style_endpoint' => true,
    'credentials' => [
        'key'    => 'Enter Access Key',
        'secret' => 'Enter Secret Key',
    ],
   'http'    => [
       'verify' => false
    ]
]);

try {
    $s3->createBucket(array('Bucket' => 'testbucket'));
}
catch (Exception $e){
    echo "There is a bucket with that name!<br>";
}

// Sending a PutObject request and getting the results
$insert = $s3->putObject([
    'Bucket' => 'testbucket',
    'Key'    => 'testkey',
    'Body'   => 'Hello world'
]);

// Download the contents of the object
$retrive = $s3->getObject([
    'Bucket' => 'testbucket',
    'Key'    => 'testkey',
    'SaveAs' => 'testkey_local'
]);

//Index the body to the result object
echo $retrive['Body'];

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.CannedAccessControlList;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.PutObjectRequest;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import com.amazonaws.services.s3.model.GetBucketLocationRequest;

public class s3Example {
    
   private static final String SERVICE_ENDPOINT = "https://******.mncdn.com";
   private static final String REGION = "us-east-1";
   private static final String ACCESS_KEY = "******";
   private static final String SECRET_KEY = "******";

   private static final String BUCKET_NAME = "bucket";

   private static final AmazonS3 AMAZON_S3_CLIENT = 
       AmazonS3ClientBuilder.standard()
       .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(SERVICE_ENDPOINT, REGION))
       .withCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY)))
       .withPathStyleAccessEnabled(true)
       .build();

   public static String uploadFile(byte[] data) throws IOException {
       try (InputStream inputStream = new ByteArrayInputStream(data)) {
           String filename = "test.txt";

           ObjectMetadata metadata = new ObjectMetadata();
           metadata.setContentLength(data.length);

           PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, filename, inputStream, metadata)
                   .withCannedAcl(CannedAccessControlList.PublicRead);

           AMAZON_S3_CLIENT.putObject(putObjectRequest);

           return AMAZON_S3_CLIENT.getUrl(BUCKET_NAME, filename).toString();
       }
   }

   public static void main(String[] args) {
       if (!AMAZON_S3_CLIENT.doesBucketExistV2(BUCKET_NAME)) {
           AMAZON_S3_CLIENT.createBucket(new CreateBucketRequest(BUCKET_NAME));

           String bucketLocation = AMAZON_S3_CLIENT.getBucketLocation(new GetBucketLocationRequest(BUCKET_NAME));
           System.out.println("Bucket location: " + bucketLocation);
       }

       try {
           uploadFile("Hello World".getBytes());
       } catch (IOException e) {
           e.printStackTrace();
       }
       System.out.println("Hello, World");
   }
}

pip install awscli

aws configure
AWS Access Key ID [None]: xxxxxxxxxxxxxxxxxx
AWS Secret Access Key [None]: yyyyyyyyyyyyyyyyyyy
Default region name [None]: ENTER
Default output format [None]: ENTER

aws --endpoint-url https://xxxxx.mncdn.com s3 ls

aws --endpoint-url https://xxxxx.mncdn.com s3 ls s3://testbucket1

aws --endpoint-url https://xxxxx.mncdn.com s3 mb s3://bucket2

aws --endpoint-url https://xxxxx.mncdn.com s3 cp hello_world.txt s3://mybucket

aws --endpoint-url https://xxxxx.mncdn.com s3 rm s3://mybucket/hello_world.txt

aws --endpoint-url https://xxxxx.mncdn.com s3 rb s3://mybucket

npm install aws-sdk

var AWS = require('aws-sdk');

var config = { s3ForcePathStyle: true };
var credentials = new AWS.SharedIniFileCredentials({profile: 'medianova'});
AWS.config.credentials = credentials;
AWS.config.update(config);

var ep = new AWS.Endpoint('*******.mncdn.com');
var s3 = new AWS.S3({endpoint: ep});

var bucketName = 'medianovatest';
var keyName = 'hello_world.txt';

s3.createBucket({Bucket: bucketName}, function() {     
    var params = {Bucket: bucketName, Key: keyName, Body: 'Hello World!'};
    s3.putObject(params, function(err, data) {
        if (err) console.log(err);
        else console.log("Successfully uploaded data to " + bucketName + "/" + keyName);
    });
});

{
  "accessKeyId": "your_medianova_access_key",
  "secretAccessKey": "your_medianova_secret_key",
  "region": "us-east-1"
}

AWS_PROFILE=medianova node sample.js

Successfully uploaded data to node-sdk-sample-xxxx/hello_world.txt

composer require aws/aws-sdk-php-laravel

'providers' => [
    Aws\Laravel\AwsServiceProvider::class,
],

'aliases' => [
    'AWS' => Aws\Laravel\AwsFacade::class,
],

php artisan vendor:publish --provider="Aws\Laravel\AwsServiceProvider"

return [
    'credentials' => [
        'key'    => env('YOUR_STOOK_ACCESS_KEY_ID'),
        'secret' => env('YOUR_STOOK_SECRET_ACCESS_KEY'),
    ],
    'region' => env('YOUR_STOOK_REGION', 'us-east-1'),
    'version' => 'latest',
    'ua_append' => [
        'L5MOD/' . AwsServiceProvider::VERSION,
    ],
    'endpoint' => env('YOUR_STOOK_ENDPOINT'),
    'use_path_style_endpoint' => true,
    'http' => [
        'verify' => false
    ]
];

YOUR_STOOK_ACCESS_KEY_ID=xxxxxxxxxxxxxxxx
YOUR_STOOK_SECRET_ACCESS_KEY=yyyyyyyyyyyyyyyyyyyy
YOUR_STOOK_ENDPOINT=https://xxxxx.mncdn.com

public function uploadStookFile(Request $request)
{
    // File information
    $fileExtension = $request->file('image')->getClientOriginalExtension();
    $fileFullName = "testFile" . '.' . $fileExtension;

    try {
        $s3 = App::make('aws')->createClient('s3');
        $s3->putObject([
            'Bucket'     => "test-bucket",
            'Key'        => $fileFullName,
            'SourceFile' => $request->file('image')->getRealPath(),
        ]);
    } catch (\Exception $exception) {
        throw new \Exception('File could not upload to Stook account.');
    }

var AWS = require('aws-sdk');

var config = {
    s3ForcePathStyle: true,
};

var credentials = new AWS.SharedIniFileCredentials({
    profile: 'medianova'
});

AWS.config.credentials = credentials;
AWS.config.update(config);

var ep = new AWS.Endpoint('customername.mncdn.com');
var s3 = new AWS.S3({endpoint: ep});

var myBucket = 'bucket';
var myKey = 'mykey';
var signedUrlExpireSeconds = 60 * 5;

var url = s3.getSignedUrl('getObject', {
    Bucket: myBucket,
    Key: myKey,
    Expires: signedUrlExpireSeconds
});

console.log(url);

using System;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;

namespace s3Example
{
    internal class Program
    {
        private static string bucketName = "medianovatest";
        private static string accessKey = "Enter Access Key";
        private static string secretKey = "Enter Secret Key";

        static async Task Main(string[] args)
        {
            var s3Config = new AmazonS3Config
            {
                RegionEndpoint = Amazon.RegionEndpoint.EUWest1,
                ServiceURL = "https://xxxxxxxxx.mncdn.com",
                ForcePathStyle = true
            };

            AWSCredentials awsCredentials = new BasicAWSCredentials(accessKey, secretKey);

            using (var s3Client = new AmazonS3Client(awsCredentials, s3Config))
            {
                await CreateBucket(s3Client);
            }

            Console.WriteLine("Operation completed.");
        }

        private static async Task CreateBucket(AmazonS3Client s3Client)
        {
            var createBucketRequest = new PutBucketRequest
            {
                BucketName = bucketName,
                UseClientRegion = true
            };
            try
            {
                var response = await s3Client.PutBucketAsync(createBucketRequest);
                Console.WriteLine($"Bucket creation status: {response.HttpStatusCode}");
            }
            catch (AmazonS3Exception ex)
            {
                Console.WriteLine($"{ex.Message}");
            }
        }
    }
}

aws s3api --endpoint-url https://<ENDPOINT_URL> \
  head-object \
  --bucket <BUCKET_NAME> \
  --key <OBJECT_KEY> \
  --profile <AWS_PROFILE>

{
  "ETag": "\"d41d8cd98f00b204e9800998ecf8427e\"",
  ...
}

mc stat <PROFILE_NAME>/<BUCKET_NAME>/<FILE_PATH> --json

{
  "etag": "d41d8cd98f00b204e9800998ecf8427e",
  ...
}

curl -I https://<ENDPOINT_URL>/<BUCKET_NAME>/<FILE_PATH>

import boto3
import hashlib

s3 = boto3.client(
    "s3",
    endpoint_url="https://endpoint_url",
    aws_access_key_id="access_key",
    aws_secret_access_key="secret_key",
)

response = s3.get_object(
    Bucket="bucket_name",
    Key="file_path",
)

md5 = hashlib.md5()

# Streaming read → do not load entire file into RAM
for chunk in response["Body"].iter_chunks(chunk_size=8192):
    if chunk:
        md5.update(chunk)

print("MD5:", md5.hexdigest())

import boto3
import hashlib

s3 = boto3.client(
    "s3",
    endpoint_url="https://endpoint_url",
    aws_access_key_id="access_key",
    aws_secret_access_key="secret_key",
)

response = s3.get_object(
    Bucket="bucket_name",
    Key="file_path",
)

sha256 = hashlib.sha256()

# Streaming read → do not load entire file into RAM
for chunk in response["Body"].iter_chunks(chunk_size=8192):
    if chunk:
        sha256.update(chunk)

print("SHA-256:", sha256.hexdigest())