Upload/Download a File

This guide demonstrates how to interact with the Flashback Platform to upload and download files in your application backend:

• AWS S3

• GCS

• Azure Blob

Prerequisites

Python

• Python 3.9+

• A Flashback Repository with a valid API key (READ or WRITE) – see Create a Repository.

• Network access to your Bridge endpoints.

Install Required Packages

pip install boto3 google-cloud-storage azure-storage-blob

Javascript

• Node.js v14+

• A Flashback Repository with a valid API key (READ or WRITE) – see Create a Repository.

• Network access to your Bridge endpoints

Install Required Packages

npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner \
            @google-cloud/storage \
            @azure/storage-blob

Go

• Go 1.18 or later

• A Flashback Repository with a valid API key (READ or WRITE) — see Create a Repository.

• Network access to your Flashback Bridge endpoints

Install required packages:

go get github.com/aws/aws-sdk-go-v2@latest
go get github.com/aws/aws-sdk-go-v2/config
go get cloud.google.com/go/storage
go get github.com/Azure/azure-sdk-for-go/sdk/storage/azblob

---

AWS S3

1

Configuration

Set up the S3 client with your Flashback endpoint and credentials:

Python

# flashback_aws_config.py
import boto3
from botocore.client import Config

# Replace with your Flashback credentials and endpoint
ENDPOINT = "https://s3-us-east-1-aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
API_KEY_ID = "YOUR_API_KEY_ID" 
API_SECRET = "YOUR_API_SECRET"

session = boto3.session.Session(
    aws_access_key_id=API_KEY_ID,
    aws_secret_access_key=API_SECRET
)

s3_client = session.client(
    service_name="s3",
    endpoint_url=ENDPOINT,
    config=Config(signature_version="s3v4")
)

Javascript

// flashbackAwsConfig.js
import { S3Client } from "@aws-sdk/client-s3";

// Replace with your Flashback credentials and endpoint
const ENDPOINT   = "https://s3-us-east-1-aws.flashback.tech";
const API_KEY_ID = "YOUR_API_KEY_ID";
const API_SECRET = "YOUR_API_SECRET";

export const s3Client = new S3Client({
  endpoint: ENDPOINT,
  region:   "us-east-1",
  credentials: {
    accessKeyId:     API_KEY_ID,
    secretAccessKey: API_SECRET
  },
  forcePathStyle: true
});

Go

// flashback_aws_config.go
package flashback

import (
  "context"
  "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"
  s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
)

func NewS3Client() (*s3.Client, error) {
  // Replace with your Flashback endpoint and credentials
  endpoint   := "https://s3-us-east-1-aws.flashback.tech"
  apiKey     := "YOUR_API_KEY_ID"
  apiSecret  := "YOUR_API_SECRET"

  // Load default config and override credentials and endpoint
  cfg, err := config.LoadDefaultConfig(context.TODO(),
    config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(apiKey, apiSecret, "")),
    config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(
      func(service, region string, opts ...interface{}) (aws.Endpoint, error) {
        if service == s3.ServiceID {
          return aws.Endpoint{
            URL:           endpoint,
            SigningRegion: "us-east-1",
          }, nil
        }
        return aws.Endpoint{}, &aws.EndpointNotFoundError{}
      })),
  )
  if err != nil {
    return nil, err
  }

  return s3.NewFromConfig(cfg, func(o *s3.Options) {
    o.UsePathStyle = true
  }), nil
}

2

Upload a File

Upload a local file to your specified bucket:

Python

# aws_upload.py
from flashback_aws_config import s3_client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-bucket-name"
FILE_PATH = "path/to/local/file.txt"
OBJECT_NAME = FILE_PATH.split("/")[-1]

s3_client.upload_file(
    Filename=FILE_PATH,
    Bucket=BUCKET_NAME,
    Key=OBJECT_NAME
)
print(f"Uploaded {OBJECT_NAME} to {BUCKET_NAME}")

Javascript

// awsUpload.js
import { PutObjectCommand } from "@aws-sdk/client-s3";
import fs                  from "fs";
import { s3Client }        from "./flashbackAwsConfig.js";

const BUCKET_NAME = "your-bucket-name";
const FILE_PATH   = "path/to/local/file.txt";
const OBJECT_NAME = FILE_PATH.split("/").pop();
const BODY        = fs.readFileSync(FILE_PATH);

(async () => {
  await s3Client.send(new PutObjectCommand({
    Bucket: BUCKET_NAME,
    Key:    OBJECT_NAME,
    Body
  }));
  console.log(`Uploaded ${OBJECT_NAME} to ${BUCKET_NAME}`);
})();

Go

// aws_upload.go
package main

import (
  "context"
  "fmt"
  "flashback"
  "os"
)

func main() {
  client, err := flashback.NewS3Client()
  if err != nil {
    panic(err)
  }

  bucket := "your-bucket-name"
  key    := "file.txt"
  file, err := os.Open("path/to/local/file.txt")
  if err != nil {
    panic(err)
  }
  defer file.Close()

  _, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
    Bucket: aws.String(bucket),
    Key:    aws.String(key),
    Body:   file,
  })
  if err != nil {
    panic(err)
  }

  fmt.Printf("Uploaded %s to %s\n", key, bucket)
}

3

Download a File

Download an object from your repository to a local path:

Python

# aws_download.py
from flashback_aws_config import s3_client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-bucket-name"
OBJECT_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

s3_client.download_file(
    Bucket=BUCKET_NAME,
    Key=OBJECT_NAME,
    Filename=DEST_PATH
)
print(f"Downloaded {OBJECT_NAME} to {DEST_PATH}")

Javascript

// awsDownload.js
import { GetObjectCommand } from "@aws-sdk/client-s3";
import fs                  from "fs";
import { s3Client }        from "./flashbackAwsConfig.js";

const BUCKET_NAME = "your-bucket-name";
const OBJECT_NAME = "file.txt";
const DEST_PATH   = "downloads/file.txt";

(async () => {
  const { Body } = await s3Client.send(new GetObjectCommand({
    Bucket: BUCKET_NAME,
    Key:    OBJECT_NAME
  }));
  const chunks = [];
  for await (let chunk of Body) chunks.push(chunk);
  fs.writeFileSync(DEST_PATH, Buffer.concat(chunks));
  console.log(`Downloaded ${OBJECT_NAME} to ${DEST_PATH}`);
})();

Go

// aws_download.go
package main

import (
  "context"
  "fmt"
  "flashback"
  "io"
  "os"
)

func main() {
  client, err := flashback.NewS3Client()
  if err != nil {
    panic(err)
  }

  bucket   := "your-bucket-name"
  key      := "file.txt"
  destPath := "downloads/file.txt"

  resp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
    Bucket: aws.String(bucket),
    Key:    aws.String(key),
  })
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  outFile, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer outFile.Close()

  if _, err = io.Copy(outFile, resp.Body); err != nil {
    panic(err)
  }

  fmt.Printf("Downloaded %s to %s\n", key, destPath)
}

---

Google Cloud Storage

1

Configuration

Initialize a GCS client pointing to your Flashback Bridge endpoint:

Python

# flashback_gcs_config.py
from google.cloud import storage
from google.oauth2 import service_account

# Replace with your Flashback credentials and endpoint
ENDPOINT = "https://s3-us-east-1.aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
CLIENT_EMAIL = "YOUR_CLIENT_EMAIL"
PRIVATE_KEY = "YOUR_PRIVATE_KEY"

credentials = service_account.Credentials.from_service_account_info({
    "type": "service_account",
    "client_email": CLIENT_EMAIL,
    "private_key": PRIVATE_KEY,
})

client = storage.Client(
    credentials=credentials,
    client_options={"api_endpoint": ENDPOINT}
)

Javascript

// flashbackGcsConfig.js
import { Storage } from '@google-cloud/storage';

// Replace with your Flashback credentials and endpoint
const ENDPOINT     = 'https://s3-us-east-1.aws.flashback.tech';
const CLIENT_EMAIL = 'YOUR_CLIENT_EMAIL';
const PRIVATE_KEY  = 'YOUR_PRIVATE_KEY';

// Initialize client
const storage = new Storage({
  credentials: {
    client_email: CLIENT_EMAIL,
    private_key: PRIVATE_KEY.replace(/\\n/g, '\n'),
  },
  apiEndpoint: ENDPOINT.replace(/^https?:\/\//, ''),
});

export default storage;
)

Go

// flashback_gcs_config.go
package flashback

import (
  "context"
  "fmt"
  "cloud.google.com/go/storage"
  "google.golang.org/api/option"
)

const (
  // Replace with your Flashback Bridge endpoint and service account info
  ENDPOINT     = "https://s3-us-east-1.aws.flashback.tech"
  CLIENT_EMAIL = "YOUR_CLIENT_EMAIL"
  PRIVATE_KEY  = `-----BEGIN PRIVATE KEY-----
YOUR_PRIVATE_KEY_CONTENT
-----END PRIVATE KEY-----`
  // The GCP project ID associated with your Flashback repository
  PROJECT_ID   = "your-gcp-project-id"
)

func NewGCSClient() (*storage.Client, string, error) {
  ctx := context.Background()
  credsJSON := []byte(fmt.Sprintf(
    `{"type":"service_account","client_email":"%s","private_key":"%s"}`,
    CLIENT_EMAIL, PRIVATE_KEY,
  ))
  client, err := storage.NewClient(ctx,
    option.WithCredentialsJSON(credsJSON),
    option.WithEndpoint(ENDPOINT),
  )
  if err != nil {
    return nil, "", err
  }
  return client, PROJECT_ID, nil
}

2

Upload a File as a Blob

Upload a blob to the specified GCS bucket:

Python

# gcs_upload.py
from flashback_gcs_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-flashback-bucket-name"
FILE_PATH = "path/to/local/file.txt"
OBJECT_NAME = FILE_PATH.split("/")[-1]

bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.upload_from_filename(FILE_PATH)
print(f"Uploaded {OBJECT_NAME} to {BUCKET_NAME}")

Javascript

// gcsUpload.js
import storage from './flashbackGcsConfig.js';

const BUCKET_NAME = 'your-flashback-bucket-name';
const FILE_PATH   = 'path/to/local/file.txt';
const OBJECT_NAME = FILE_PATH.split('/').pop();

(async () => {
  const bucket = storage.bucket(BUCKET_NAME);
  await bucket.upload(FILE_PATH, { destination: OBJECT_NAME });
  console.log(`Uploaded ${OBJECT_NAME} to ${BUCKET_NAME}`);
})();

Go

// gcs_upload.go
package main

import (
  "context"
  "fmt"
  "flashback"
  "io"
  "os"
)

func main() {
  client, _, err := flashback.NewGCSClient()
  if err != nil {
    panic(err)
  }
  ctx := context.Background()
  bucketName := "your-flashback-bucket-name"
  filePath   := "path/to/local/file.txt"
  objectName := "file.txt"

  bucket := client.Bucket(bucketName)
  writer := bucket.Object(objectName).NewWriter(ctx)
  f, err := os.Open(filePath)
  if err != nil {
    panic(err)
  }
  defer f.Close()
  if _, err = io.Copy(writer, f); err != nil {
    panic(err)
  }
  if err := writer.Close(); err != nil {
    panic(err)
  }
  fmt.Printf("Uploaded %s to %s\n", objectName, bucketName)
}

3

Download a File as a Blob

Download a blob from your repository:

Python

# gcs_download.py
from flashback_gcs_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-bucket-name"
OBJECT_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.download_to_filename(DEST_PATH)
print(f"Downloaded {OBJECT_NAME} to {DEST_PATH}")

Javascript

// gcsDownload.js
import storage from './flashbackGcsConfig.js';

const BUCKET_NAME = 'your-bucket-name';
const OBJECT_NAME = 'file.txt';
const DEST_PATH   = 'downloads/file.txt';

(async () => {
  const bucket = storage.bucket(BUCKET_NAME);
  const blob = bucket.file(OBJECT_NAME);
  await blob.download({ destination: DEST_PATH });
  console.log(`Downloaded ${OBJECT_NAME} to ${DEST_PATH}`);
})();

Go

// gcs_download.go
package main

import (
  "context"
  "fmt"
  "flashback"
  "io"
  "os"
)

func main() {
  client, _, err := flashback.NewGCSClient()
  if err != nil {
    panic(err)
  }
  ctx := context.Background()
  bucketName := "your-bucket-name"
  objectName := "file.txt"
  destPath   := "downloads/file.txt"

  reader, err := client.Bucket(bucketName).Object(objectName).NewReader(ctx)
  if err != nil {
    panic(err)
  }
  defer reader.Close()
  f, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer f.Close()
  if _, err = io.Copy(f, reader); err != nil {
    panic(err)
  }
  fmt.Printf("Downloaded %s to %s\n", objectName, destPath)
}

---

Azure Blob Storage

1

Configuration

Create an Azure BlobServiceClient using your Flashback endpoint:

Python

# flashback_azure_config.py
from azure.storage.blob import BlobServiceClient

# Replace with your Flashback endpoint and credentials
ENDPOINT = "https://s3-us-east-1.aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
CREDENTIAL = "YOUR_CREDENTIAL"

client = BlobServiceClient(
    account_url=ENDPOINT,
    credential=CREDENTIAL
)

Javascript

// flashbackAzureConfig.js
import { BlobServiceClient, StorageSharedKeyCredential } from "@azure/storage-blob";

// Replace with your Flashback endpoint and credential
const ENDPOINT   = "https://s3-us-east-1.aws.flashback.tech";
const ACCOUNT    = "YOUR_ACCOUNT_NAME";
const ACCOUNT_KEY= "YOUR_ACCOUNT_KEY";

const credential = new StorageSharedKeyCredential(ACCOUNT, ACCOUNT_KEY);
export const blobServiceClient = new BlobServiceClient(ENDPOINT, credential);

Go

// flashback_azure_config.go
package flashback

import (
  "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

// Replace with your Flashback endpoint and credentials
const (
  ENDPOINT     = "https://s3-us-east-1.aws.flashback.tech"
  ACCOUNT_NAME = "YOUR_ACCOUNT_NAME"
  ACCOUNT_KEY  = "YOUR_ACCOUNT_KEY"
)

// NewBlobServiceClient returns an authenticated ServiceClient
func NewBlobServiceClient() (*azblob.ServiceClient, error) {
  cred, err := azblob.NewSharedKeyCredential(ACCOUNT_NAME, ACCOUNT_KEY)
  if err != nil {
    return nil, err
  }
  return azblob.NewServiceClientWithSharedKey(ENDPOINT, cred, nil)
}

2

Upload a File as a Blob

Upload a local file as a blob to your bucket:

Python

# azure_upload.py
from flashback_azure_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
CONTAINER_NAME = "your-bucket_name"
FILE_PATH = "path/to/local/file.txt"
BLOB_NAME = FILE_PATH.split("/")[-1]

blob_client = client.get_blob_client(container=CONTAINER_NAME, blob=BLOB_NAME)
with open(FILE_PATH, "rb") as data:
    blob_client.upload_blob(data)
print(f"Uploaded {BLOB_NAME} to {CONTAINER_NAME}")

Javascript

// azureUpload.js
import { blobServiceClient } from "./flashbackAzureConfig.js";
import fs                     from "fs";

const CONTAINER_NAME = "your-bucket-name";
const FILE_PATH      = "path/to/local/file.txt";
const BLOB_NAME      = FILE_PATH.split("/").pop();

(async () => {
  const containerClient = blobServiceClient.getContainerClient(CONTAINER_NAME);
  const blockBlobClient = containerClient.getBlockBlobClient(BLOB_NAME);
  await blockBlobClient.uploadFile(FILE_PATH);
  console.log(`Uploaded ${BLOB_NAME} to ${CONTAINER_NAME}`);
})();

Go

// azure_upload.go
package main

import (
  "context"
  "fmt"
  "flashback"
  "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

func main() {
  client, err := flashback.NewBlobServiceClient()
  if err != nil {
    panic(err)
  }
  containerName := "your-bucket-name"
  blobName      := "file.txt"
  localPath     := "path/to/local/file.txt"

  containerClient := client.NewContainerClient(containerName)
  blobClient := containerClient.NewBlockBlobClient(blobName)

  resp, err := blobClient.UploadFile(context.Background(), localPath, nil)
  if err != nil {
    panic(err)
  }
  fmt.Printf("Uploaded %s to %s (request ID: %s)\n", blobName, containerName, *resp.RequestID)
}

3

Download a File as a Blob

Download a blob from your container to a local path:

Python

# azure_download.py
from flashback_azure_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
CONTAINER_NAME = "your-flashback-bucket_name"
BLOB_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

blob_client = client.get_blob_client(container=CONTAINER_NAME, blob=BLOB_NAME)
with open(DEST_PATH, "wb") as file:
    data = blob_client.download_blob()
    file.write(data.readall())
print(f"Downloaded {BLOB_NAME} to {DEST_PATH}")

Javascript

// azureDownload.js
import { blobServiceClient } from "./flashbackAzureConfig.js";
import fs                     from "fs";

const CONTAINER_NAME = "your-flashback-bucket-name";
const BLOB_NAME      = "file.txt";
const DEST_PATH      = "downloads/file.txt";

(async () => {
  const containerClient = blobServiceClient.getContainerClient(CONTAINER_NAME);
  const blockBlobClient = containerClient.getBlockBlobClient(BLOB_NAME);
  await blockBlobClient.downloadToFile(DEST_PATH);
  console.log(`Downloaded ${BLOB_NAME} to ${DEST_PATH}`);
})();

Go

// azure_download.go
package main

import (
  "context"
  "fmt"
  "io"
  "os"
  "flashback"
)

func main() {
  client, err := flashback.NewBlobServiceClient()
  if err != nil {
    panic(err)
  }
  containerName := "your-flashback-bucket-name"
  blobName      := "file.txt"
  destPath      := "downloads/file.txt"

  containerClient := client.NewContainerClient(containerName)
  blobClient := containerClient.NewBlockBlobClient(blobName)

  downloadResp, err := blobClient.DownloadStream(context.Background(), nil)
  if err != nil {
    panic(err)
  }
  defer downloadResp.Body.Close()

  outFile, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer outFile.Close()

  if _, err = io.Copy(outFile, downloadResp.Body); err != nil {
    panic(err)
  }
  fmt.Printf("Downloaded %s to %s\n", blobName, destPath)
}

---

Next Steps

• Explore additional storage API operations: delete, copy, multipart uploads, etc.

• Integrate and modify these snippets into your applications.