Overview

The View Multipart Upload management system provides comprehensive support for efficient large file uploads and data transfer operations. Multipart uploads enable the transfer of large files by breaking them into smaller, manageable parts that can be uploaded independently and then assembled into the final object.

Key Features

Large File Support: Efficient handling of large files through part-based upload architecture
Parallel Upload: Support for concurrent part uploads to maximize transfer performance
Resume Capability: Ability to resume interrupted uploads by re-uploading individual parts
Part Management: Complete lifecycle management of upload parts including creation, retrieval, and deletion
Upload Completion: Secure assembly of parts into final objects with integrity verification
Expiration Control: Configurable expiration times for incomplete multipart uploads
Progress Tracking: Comprehensive tracking of upload progress and part status
Error Recovery: Robust error handling and recovery mechanisms for failed uploads

Supported Operations

Create: Initialize new multipart upload sessions for large file transfers
Read: Retrieve multipart upload metadata and configuration details
Read All: List all multipart uploads in a bucket
Upload Part: Upload individual parts of the multipart upload
Retrieve Part: Retrieve specific parts of a multipart upload
Delete Part: Remove individual parts from multipart uploads
Complete Upload: Finalize multipart uploads by assembling all parts
Delete Upload: Cancel and remove multipart upload sessions

API Endpoints

Multipart uploads are managed via the Storage server API at [http|https]://[hostname]:[port]/v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads

Default Ports:

View REST API: Port 8001
S3-Compatible API: Port 8002

Supported HTTP Methods: GET, HEAD, PUT, DELETE, POST

Important: All multipart upload operations require appropriate authentication tokens.

Multipart Upload Object Structure

Multipart upload objects contain comprehensive metadata for managing large file upload sessions. Here's the complete structure:

{
    "GUID": "31a2b7b8-dc22-4e93-ad9d-5bab6d78d81b",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "PoolGUID": "00000000-0000-0000-0000-000000000000",
    "NodeGUID": "eb8f61fb-2a01-4edc-974b-fbb79d1a61c8",
    "OwnerGUID": "00000000-0000-0000-0000-000000000000",
    "UploadGUID": "af08c091-c82a-4034-9a49-348850b8e5f8",
    "Key": "foo.txt",
    "StartedUtc": "2025-04-03T09:52:05.002013Z",
    "LastAccessUtc": "2025-04-03T09:52:05.002013Z",
    "CreatedUtc": "2025-04-03T09:52:05.002014Z",
    "ExpirationUtc": "2025-04-10T09:52:05.017974Z",
    "Parts": []
}

Field Descriptions

GUID (GUID): Globally unique identifier for the multipart upload object
TenantGUID (GUID): Globally unique identifier for the tenant
BucketGUID (GUID): Globally unique identifier for the bucket containing the upload
PoolGUID (GUID): Globally unique identifier for the storage pool
NodeGUID (GUID): Globally unique identifier for the node handling the upload
OwnerGUID (GUID): Globally unique identifier for the user who initiated the upload
UploadGUID (GUID): Globally unique identifier for the upload session
Key (string): File name/key for the object being uploaded
StartedUtc (datetime): UTC timestamp when the upload session was started
LastAccessUtc (datetime): UTC timestamp of the last access to the upload
CreatedUtc (datetime): UTC timestamp when the upload was created
ExpirationUtc (datetime): UTC timestamp when the upload will expire
Parts (array): Array of uploaded parts with metadata

Important Notes

Large File Handling: Multipart uploads are designed for efficient transfer of large files
Part Management: Individual parts can be uploaded, retrieved, and managed independently
Expiration Control: Incomplete uploads automatically expire to prevent resource waste
Resume Capability: Failed uploads can be resumed by re-uploading specific parts

Create Multipart Upload

Creates a new multipart upload session using PUT /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads. This endpoint initializes a multipart upload session for efficient large file transfer.

Request Parameters

Required Parameters

Key (string, Body, Required): File name/key for the object to be uploaded

Important Notes

Upload Session: Creates a new multipart upload session for large file handling
Part Management: Individual parts can be uploaded after session creation
Expiration: Upload sessions have configurable expiration times
Resume Support: Failed uploads can be resumed by re-uploading specific parts

curl --location --request PUT 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads' \
--header 'Content-Type: text/plain' \
--header 'Authorization: ••••••' \
--data '{
    "Key": "foo.txt"
}'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const createMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.create(
      "<bucket-guid>",
      {
        Key: "hello.txt",
      }
    );
    console.log(response, "Multipart upload created successfully");
  } catch (err) {
    console.log("Error creating multipart upload:", err);
  }
};

createMultipartUpload();

import view_sdk
from view_sdk import storage

sdk = view_sdk.configure( access_key="default",base_url="localhost", tenant_guid= "<tenant-guid>")

def createMultipartUpload():
    object = storage.MultipartUploads.create(bucket_guid="<bucket-guid>",Key="foo.txt")
    print(object)

createMultipartUpload()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");
MultipartUploadMetadata obj = new MultipartUploadMetadata
{
  Key= "hello.txt",
}
MultipartUploadMetadata response = await sdk.MultipartUpload.Create(Guid.Parse("<bucket-guid>"), obj);

Response

Returns the created multipart upload object with all configuration details:

{
    "GUID": "31a2b7b8-dc22-4e93-ad9d-5bab6d78d81b",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "PoolGUID": "00000000-0000-0000-0000-000000000000",
    "NodeGUID": "eb8f61fb-2a01-4edc-974b-fbb79d1a61c8",
    "OwnerGUID": "00000000-0000-0000-0000-000000000000",
    "UploadGUID": "af08c091-c82a-4034-9a49-348850b8e5f8",
    "Key": "hello.txt",
    "StartedUtc": "2025-04-03T09:52:05.002013Z",
    "LastAccessUtc": "2025-04-03T09:52:05.002013Z",
    "CreatedUtc": "2025-04-03T09:52:05.002014Z",
    "ExpirationUtc": "2025-04-10T09:52:05.017974Z",
    "Parts": []
}

Read Multipart Upload

Retrieves multipart upload metadata by key using GET /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]. Returns the complete upload session information including part details and status. If the upload doesn't exist, a 404 error is returned.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload to retrieve

curl --location 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/hello.txt' \
--header 'Authorization: ••••••' \

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const retrieveMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.read(
      "<bucket-guid>",
      "hello.txt"
    );
    console.log(response, "Multipart upload retrieved successfully");
  } catch (err) {
    console.log("Error retrieving multipart upload:", err);
  }
};
retrieveMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def retrieveMultipartUpload():
    object = storage.MultipartUploads.retrieve("<bucket-guid>", "foo.txt",)
    print(object)

retrieveMultipartUpload()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

MultipartUploadMetadata response = await sdk.MultipartUpload.Retrieve(Guid.Parse("<bucket-guid>"), Guid.Parse("<upload-guid>"));

Response

Returns the complete multipart upload metadata:

{
    "GUID": "31a2b7b8-dc22-4e93-ad9d-5bab6d78d81b",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "BucketGUID": "00000000-0000-0000-0000-000000000000",
    "PoolGUID": "00000000-0000-0000-0000-000000000000",
    "NodeGUID": "eb8f61fb-2a01-4edc-974b-fbb79d1a61c8",
    "OwnerGUID": "00000000-0000-0000-0000-000000000000",
    "UploadGUID": "af08c091-c82a-4034-9a49-348850b8e5f8",
    "Key": "hello.txt",
    "StartedUtc": "2025-04-03T09:52:05.002013Z",
    "LastAccessUtc": "2025-04-03T09:52:05.002013Z",
    "CreatedUtc": "2025-04-03T09:52:05.002014Z",
    "ExpirationUtc": "2025-04-10T09:52:05.017974Z",
    "Parts": [
        {
            "PartNumber": 1,
            "ETag": "d41d8cd98f00b204e9800998ecf8427e",
            "Size": 0,
            "LastModified": "2025-04-03T09:52:05.002013Z"
        }
    ]
}

Read All Multipart Uploads

Retrieves all multipart uploads in a bucket using GET /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads. Returns an array of multipart upload objects with complete session details for all active uploads in the bucket.

Request Parameters

bucket-guid (string, Path, Required): GUID of the bucket to list multipart uploads from

curl --location --request GET 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads' \
--header 'Content-Type: text/plain' \
--header 'Authorization: ••••••' \

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const retrieveMultipartUploads = async () => {
  try {
    const response = await api.multipartUpload.readAll(
      "<bucket-guid>"
    );

    console.log(response, "Multipart uploads retrieved successfully");
  } catch (err) {
    console.log("Error retrieving multipart uploads:", err);
  }
};
retrieveMultipartUploads();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def readAllMultipartUploads():
    object = storage.MultipartUploads.retrieve_all("<bucket-guid>")
    print(object)

readAllMultipartUploads()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

List<MultipartUploadMetadata> response = await sdk.MultipartUpload.RetrieveMany(Guid.Parse("<bucket-guid>"));

Response

Returns an array of all multipart upload objects:

[
    {
        "GUID": "31a2b7b8-dc22-4e93-ad9d-5bab6d78d81b",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "BucketGUID": "00000000-0000-0000-0000-000000000000",
        "PoolGUID": "00000000-0000-0000-0000-000000000000",
        "NodeGUID": "eb8f61fb-2a01-4edc-974b-fbb79d1a61c8",
        "OwnerGUID": "00000000-0000-0000-0000-000000000000",
        "UploadGUID": "af08c091-c82a-4034-9a49-348850b8e5f8",
        "Key": "hello.txt",
        "StartedUtc": "2025-04-03T09:52:05.002013Z",
        "LastAccessUtc": "2025-04-03T09:52:05.002013Z",
        "CreatedUtc": "2025-04-03T09:52:05.002014Z",
        "ExpirationUtc": "2025-04-10T09:52:05.017974Z",
        "Parts": []
    },
    {
        "GUID": "another-upload-guid",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "BucketGUID": "00000000-0000-0000-0000-000000000000",
        "PoolGUID": "00000000-0000-0000-0000-000000000000",
        "NodeGUID": "eb8f61fb-2a01-4edc-974b-fbb79d1a61c8",
        "OwnerGUID": "00000000-0000-0000-0000-000000000000",
        "UploadGUID": "another-upload-session-guid",
        "Key": "large-file.zip",
        "StartedUtc": "2025-04-03T10:15:30.123456Z",
        "LastAccessUtc": "2025-04-03T10:15:30.123456Z",
        "CreatedUtc": "2025-04-03T10:15:30.123456Z",
        "ExpirationUtc": "2025-04-10T10:15:30.123456Z",
        "Parts": [
            {
                "PartNumber": 1,
                "ETag": "d41d8cd98f00b204e9800998ecf8427e",
                "Size": 5242880,
                "LastModified": "2025-04-03T10:15:30.123456Z"
            }
        ]
    }
]

Upload Part

Uploads a specific part of a multipart upload using PUT /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]/parts?partNumber=3. This endpoint allows you to upload individual parts of a large file for efficient transfer.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload
partNumber (integer, Query, Required): Part number for the upload (1-based indexing)
Part Data (binary, Body, Required): The actual data content for the part

curl --location --request PUT 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/hello.txt/parts?partNumber=3' \
--header 'Content-Type: text/plain' \
--header 'Authorization: ••••••' \
--data 'Part 3.'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const uploadPartOfMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.uploadPart(
      "<bucket-guid>",
      "hello.txt",
      1,
      "Hey There"
    );

    console.log(response, "part uploaded successfully");
  } catch (err) {
    console.log("Error uploading part:", err);
  }
};

uploadPartOfMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def uploadMultipartUpload():
    object = storage.MultipartUploads.upload_part("<bucket-guid>", "foo.txt", 1, "test")
    print(object)

uploadMultipartUpload()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

PartMetadata response = await sdk.MultipartUpload.UploadPart(Guid.Parse("<bucket-guid>"),  Guid.Parse("<upload-guid>"), 1, "test")

Response

Returns the uploaded part metadata:

{
    "PartNumber": 1,
    "ETag": "d41d8cd98f00b204e9800998ecf8427e",
    "Size": 4,
    "LastModified": "2025-04-03T09:52:05.002013Z"
}

Retrieve Part

Retrieves a specific part of a multipart upload using GET /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]/parts?partNumber=3. Returns the data content of the specified part for verification or recovery purposes.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload
partNumber (integer, Query, Required): Part number to retrieve (1-based indexing)

curl --location 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/foo.txt?partNumber=1' \
--header 'Authorization: ••••••'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const retrievePartOfMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.readPart(
      "<bucket-guid>",
      "hello.txt",
      1
    );

    console.log(response, "part retrieved successfully");
  } catch (err) {
    console.log("Error retrieving part:", err);
  }
};

retrievePartOfMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def readMultipartUploadPart():
    object = storage.MultipartUploads.retrieve_part("<bucket-guid>", "foo.txt", 1)
    print(object)

readMultipartUploadPart()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

string response = await sdk.MultipartUpload.RetrievePart(Guid.Parse("<bucket-guid>"), "foo.txt", 1);

Response

Returns the part data content:

Hey There

Delete Part

Deletes a specific part of a multipart upload using DELETE /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]?partNumber=1. This operation removes the specified part from the upload session.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload
partNumber (integer, Query, Required): Part number to delete (1-based indexing)

curl --location --request DELETE 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/foo.txt?partNumber=1' \
--header 'Authorization: ••••••'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const deletePartOfMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.deletePart(
      "<bucket-guid>",
      "hello.txt",
      1
    );
    console.log(response, "part deleted successfully");
  } catch (err) {
    console.log("Error deleting part:", err);
  }
};
deletePartOfMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def deleteMultipartUploadPart():
    object = storage.MultipartUploads.delete_part("<bucket-guid>", "hello.txt", 1)
    print(object)

deleteMultipartUploadPart()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

bool deleted = await sdk.MultipartUpload.DeletePart(Guid.Parse("<bucket-guid>"), Guid.Parse("<upload-guid>"), 1)

Response

Returns 204 No Content on successful deletion. No response body is returned.

Delete Multipart Upload

Deletes a multipart upload session using DELETE /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]. This operation cancels the upload session and removes all associated parts.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload to delete

curl --location --request DELETE 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/foo.txt' \
--header 'Authorization: ••••••'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const deleteMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.delete(
      "<bucket-guid>",
      "hello.txt"
    );

    console.log(response, "part deleted successfully");
  } catch (err) {
    console.log("Error deleting multipart upload:", err);
  }
};
deleteMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def deleteMultipartUpload():
    object = storage.MultipartUploads.delete("<bucket-guid>", "foo.txt")
    print(object)

deleteMultipartUpload()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

bool deleted = await sdk.MultipartUpload.DeleteUpload(Guid.Parse("<bucket-guid>"), Guid.Parse("<upload-guid>"));

Response

Returns 204 No Content on successful deletion. No response body is returned.

Complete Multipart Upload

Completes a multipart upload session using POST /v1.0/tenants/[tenant-guid]/buckets/[bucket-guid]/uploads/[key]. This operation assembles all uploaded parts into the final object and finalizes the upload process.

Request Parameters

key (string, Path, Required): File name/key of the multipart upload to complete

Important Notes

Part Assembly: All uploaded parts are assembled into the final object
Integrity Verification: The system verifies part integrity during completion
Object Creation: The final object is created and made available for access
Session Cleanup: The multipart upload session is cleaned up after successful completion

curl --location --request POST 'http://localhost:8001/v1.0/tenants/00000000-0000-0000-0000-000000000000/buckets/00000000-0000-0000-0000-000000000000/uploads/foo.txt' \
--header 'Authorization: ••••••'

import { ViewStorageSdk } from "view-sdk";

const api = new ViewStorageSdk(
  "http://localhost:8001/", //endpoint
  "<tenant-guid>", //tenant Id
  "default" //access key
);

const completeMultipartUpload = async () => {
  try {
    const response = await api.multipartUpload.complete(
      "<bucket-guid>",
      "hello.txt"
    );

    console.log(response, "multipart upload completed successfully");
  } catch (err) {
    console.log("Error completing multipart upload:", err);
  }
};
completeMultipartUpload();

import view_sdk
from view_sdk import storage
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost",
    tenant_guid="tenant-guid",
    service_ports={Service.STORAGE: 8001},
)

def completeMultipartUpload():
    object = storage.MultipartUploads.complete_upload("<bucket-guid>", "foo.txt")
    print(object)

completeMultipartUpload()

using View.Sdk;
using View.Storage;

ViewStorageSdk sdk = new ViewStorageSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"), 
                                        "default", 
                                        "http://localhost:8000/");

ObjectMetadata response = await sdk.MultipartUpload.CompleteUpload(Guid.Parse("<bucket-guid>"), Guid.Parse("<upload-guid>"), "foo.txt");

Response

Returns the completed object metadata:

{
    "GUID": "74ee4b8a-188e-4a73-8a42-3b7fb1ccb5e0",
    "TenantGUID": "default",
    "NodeGUID": "05a93a0c-bab0-4442-8444-a5863fabc9ec",
    "PoolGUID": "default",
    "BucketGUID": "example-data-bucket",
    "OwnerGUID": "default",
    "Key": "foo.txt",
    "Version": "1",
    "IsLatest": true,
    "IsDeleteMarker": false,
    "IsLocal": true,
    "ContentType": "text/plain",
    "DocumentType": "Text",
    "SourceUrl": "http://dcc249eaaf06:8001/v1.0/tenants/default/buckets/example-data-bucket/objects/foo.txt",
    "MD5Hash": "D41D8CD98F00B204E9800998ECF8427E",
    "SHA1Hash": "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709",
    "SHA256Hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
    "IsEncrypted": false,
    "WriteMode": "GUID",
    "CompressionType": "None",
    "ContentLength": 0,
    "CompressedLength": 0,
    "EncryptedLength": 0,
    "CompressionRatioPercent": 0,
    "CompressionRatioX": 0,
    "LastAccessUtc": "2025-04-03T09:52:05.002013Z",
    "LastModifiedUtc": "2025-04-03T09:52:05.002013Z",
    "CreatedUtc": "2025-04-03T09:52:05.002013Z"
}

Best Practices

When managing multipart uploads in the View platform, consider the following recommendations for optimal large file transfer performance and reliability:

Part Size Optimization: Use appropriate part sizes (typically 5-100MB) to balance upload efficiency and memory usage
Parallel Upload: Upload multiple parts concurrently to maximize transfer performance and reduce total upload time
Error Handling: Implement robust error handling and retry mechanisms for failed part uploads
Progress Tracking: Monitor upload progress and part status to provide user feedback and handle interruptions
Session Management: Properly manage upload sessions including cleanup of incomplete or failed uploads

Next Steps

After successfully implementing multipart uploads, you can:

Objects: Manage the completed objects within your buckets for data storage and retrieval
Buckets: Configure additional buckets for organizing multipart uploads and completed objects
Storage Pools: Set up storage pools to optimize data placement and performance for large files
Access Control: Configure ACL settings for secure access to multipart upload sessions and completed objects
Integration: Integrate multipart uploads with other View platform services for comprehensive data processing workflows