Uploading With a Pre-Signed URL

{
  "body": {
    "assetId": "vid_XXX",
    "resumableUploadURL": "https://storage.googleapis.com/upload/storage/v1/b/...&upload_id=...",
    "signedURL": "https://<storage-provider>/<path>?<signature>",
    "contentType": "video/mp4",
    "bucketPath": "<internal-bucket-path>",
    "expiresAt": 1640995200
  }
}

PUT {resumableUploadURL}
Content-Range: bytes 0-16777215/52428800

<16 MiB of the file>

PUT {resumableUploadURL}
Content-Range: bytes */52428800
Content-Length: 0

import os
import time
import requests

CHUNK_BYTES = 16 * 1024 * 1024  # must be a multiple of 256 KiB

def next_offset(response):
    stored = response.headers.get("Range")  # e.g. "bytes=0-16777215"
    return int(stored.split("-")[1]) + 1 if stored else 0

def stored_offset(session_url, total):
    r = requests.put(session_url, headers={"Content-Range": f"bytes */{total}"}, timeout=60)
    if r.status_code in (200, 201):
        return total
    if r.status_code == 308:
        return next_offset(r)
    r.raise_for_status()
    raise RuntimeError(f"unexpected status {r.status_code}")

def upload_resumable(session_url, file_path):
    total = os.path.getsize(file_path)
    offset = stored_offset(session_url, total)
    failures = 0
    with open(file_path, "rb") as f:
        while offset < total:
            f.seek(offset)
            chunk = f.read(CHUNK_BYTES)
            end = offset + len(chunk) - 1
            try:
                r = requests.put(
                    session_url,
                    data=chunk,
                    headers={"Content-Range": f"bytes {offset}-{end}/{total}"},
                    timeout=300,
                )
            except requests.RequestException:
                r = None

            if r is not None and r.status_code in (200, 201):
                return
            if r is not None and r.status_code == 308:
                offset = next_offset(r)
                failures = 0
                continue
            if r is not None and r.status_code in (404, 410):
                raise RuntimeError("upload session expired; request new upload URLs")
            if r is not None and r.status_code < 500 and r.status_code not in (408, 429):
                r.raise_for_status()

            failures += 1
            if failures > 10:
                raise RuntimeError("upload keeps failing; run again later to resume")
            time.sleep(min(60, 2 ** failures))
            offset = stored_offset(session_url, total)

const chunkBytes = 16 * 1024 * 1024 // must be a multiple of 256 KiB

func nextOffset(resp *http.Response) int64 {
    stored := resp.Header.Get("Range") // e.g. "bytes=0-16777215"
    if stored == "" {
        return 0
    }
    var last int64
    fmt.Sscanf(stored, "bytes=0-%d", &last)
    return last + 1
}

func storedOffset(client *http.Client, sessionURL string, total int64) (int64, error) {
    req, _ := http.NewRequest(http.MethodPut, sessionURL, nil)
    req.Header.Set("Content-Range", fmt.Sprintf("bytes */%d", total))
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()
    switch resp.StatusCode {
    case http.StatusOK, http.StatusCreated:
        return total, nil
    case http.StatusPermanentRedirect: // 308
        return nextOffset(resp), nil
    }
    return 0, fmt.Errorf("status query failed: %s", resp.Status)
}

func uploadResumable(sessionURL, filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
        return err
    }
    defer file.Close()
    info, err := file.Stat()
    if err != nil {
        return err
    }
    total := info.Size()
    client := &http.Client{Timeout: 5 * time.Minute}

    offset, err := storedOffset(client, sessionURL, total)
    if err != nil {
        return err
    }
    failures := 0
    for offset < total {
        n := min(int64(chunkBytes), total-offset)
        req, _ := http.NewRequest(http.MethodPut, sessionURL, io.NewSectionReader(file, offset, n))
        req.ContentLength = n
        req.Header.Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", offset, offset+n-1, total))

        resp, err := client.Do(req)
        if err == nil {
            io.Copy(io.Discard, resp.Body)
            resp.Body.Close()
            switch {
            case resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusCreated:
                return nil
            case resp.StatusCode == http.StatusPermanentRedirect:
                offset = nextOffset(resp)
                failures = 0
                continue
            case resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone:
                return fmt.Errorf("upload session expired; request new upload URLs")
            case resp.StatusCode < 500 && resp.StatusCode != http.StatusRequestTimeout && resp.StatusCode != http.StatusTooManyRequests:
                return fmt.Errorf("upload failed: %s", resp.Status)
            }
        }

        failures++
        if failures > 10 {
            return fmt.Errorf("upload keeps failing; run again later to resume")
        }
        time.Sleep(min(time.Minute, time.Duration(1<<failures)*time.Second))
        if offset, err = storedOffset(client, sessionURL, total); err != nil {
            return err
        }
    }
    return nil
}

const CHUNK_BYTES = 16 * 1024 * 1024; // must be a multiple of 256 KiB

function nextOffset(res) {
  const stored = res.headers.get("Range"); // e.g. "bytes=0-16777215"
  return stored ? Number(stored.split("-")[1]) + 1 : 0;
}

async function storedOffset(sessionURL, total) {
  const res = await fetch(sessionURL, {
    method: "PUT",
    headers: { "Content-Range": `bytes */${total}` },
  });
  if (res.status === 200 || res.status === 201) return total;
  if (res.status === 308) return nextOffset(res);
  throw new Error(`status query failed: ${res.status}`);
}

async function uploadResumable(sessionURL, file, onProgress) {
  const total = file.size;
  let offset = await storedOffset(sessionURL, total);
  let failures = 0;
  while (offset < total) {
    const end = Math.min(offset + CHUNK_BYTES, total);
    let res = null;
    try {
      res = await fetch(sessionURL, {
        method: "PUT",
        headers: { "Content-Range": `bytes ${offset}-${end - 1}/${total}` },
        body: file.slice(offset, end),
      });
    } catch {
      // Network error: fall through to retry.
    }

    if (res && (res.status === 200 || res.status === 201)) return;
    if (res && res.status === 308) {
      offset = nextOffset(res);
      failures = 0;
      onProgress?.(offset / total);
      continue;
    }
    if (res && (res.status === 404 || res.status === 410)) {
      throw new Error("Upload session expired; request new upload URLs");
    }
    if (res && res.status < 500 && res.status !== 408 && res.status !== 429) {
      throw new Error(`Upload failed: ${res.status}`);
    }

    failures++;
    if (failures > 10) throw new Error("Upload keeps failing; try again later to resume");
    await new Promise((r) => setTimeout(r, Math.min(60_000, 1000 * 2 ** failures)));
    offset = await storedOffset(sessionURL, total);
  }
}

file, _ := os.Open(filePath)
defer file.Close()
putReq, _ := http.NewRequest("PUT", uploadResp.Body.SignedURL, file)
putReq.Header.Set("Content-Type", uploadResp.Body.ContentType)
client.Do(putReq)

1
<!-- Replace {edgeKey} with an Edge Key -->
2
<iframe
3
  src="https://player.antcdn.net/v1/{edgeKey}/master.m3u8?autoplay=true&muted=true"
4
  frameborder="0"
5
  allowfullscreen>
6
</iframe>

const uploadWithProgress = async (file, signedURL, contentType) => {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();

    xhr.upload.addEventListener('progress', (event) => {
      if (event.lengthComputable) {
        const percentComplete = (event.loaded / event.total) * 100;
        console.log(`Upload progress: ${percentComplete.toFixed(2)}%`);
      }
    });

    xhr.addEventListener('load', () => {
      if (xhr.status === 200) {
        resolve('Upload complete');
      } else {
        reject(new Error('Upload failed'));
      }
    });

    xhr.open('PUT', signedURL);
    xhr.setRequestHeader('Content-Type', contentType);
    xhr.send(file);
  });
};