API Reference
Start typing to search…

Multipart Uploads

Comprehensive guide to View's multipart upload management system, including large file upload handling, part management, upload completion, and efficient data transfer for optimal storage performance.

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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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://view.homedns.org: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