Upload de arquivos de mídia grandes

curl -X PUT \
-H 'Content-Type: video/mp4' \
--upload-file LOCAL_FILE_PATH uploadUrl

const fs = require("fs").promises;
const uploadFileToSignedUrl = async (signedUrl, filePath) => {
    try {
      const fileBuffer = await fs.readFile(filePath);
      const response = await fetch(signedUrl, {
        method: "PUT",
        body: fileBuffer,
        headers: {
          "Content-Type": "video/mp4"
        }
      });

      if (response.ok) {
        console.log("File upload successful:", response.status);
      } else {
        console.error("File upload failed:", response.status);
      }
    } catch (error) {
      console.error("Error uploading file:", error);
    }
};

// Use the signed URL generated from the previous step
const signedUrl = "SIGNED_URL";
const filePath = "LOCAL_FILE_PATH";

uploadFileToSignedUrl(signedUrl, filePath);

import requests

def upload_file_to_signed_url(signed_url, file_path):
    try:
        with open(file_path, 'rb') as file:
            response = requests.put(signed_url, data=file, headers={'Content-Type': 'video/mp4'})

        if response.ok:
            print("File upload successful:", response.status_code)
        else:
            print("File upload failed:", response.status_code)
    except Exception as error:
        print("Error uploading file:", error)

# Use the signed URL generated from the previous step
signed_url = "SIGNED_URL"
file_path = "LOCAL_FILE_PATH"

upload_file_to_signed_url(signed_url, file_path)

<?php

function uploadFileToSignedUrl($signedUrl, $filePath) {
    try {
        $fileHandle = fopen($filePath, 'rb');
        if ($fileHandle === false) {
            throw new Exception('Cannot open the file');
        }

        $ch = curl_init($signedUrl);

        curl_setopt($ch, CURLOPT_PUT, true);
        curl_setopt($ch, CURLOPT_INFILE, $fileHandle);
        curl_setopt($ch, CURLOPT_INFILESIZE, filesize($filePath));
        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: video/mp4'));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($httpCode == 200) {
            echo "File upload successful: " . $httpCode;
        } else {
            echo "File upload failed: " . $httpCode;
        }

        fclose($fileHandle);
        curl_close($ch);
    } catch (Exception $e) {
        echo "Error uploading file: " . $e->getMessage();
    }
}

// Use the signed URL generated from the previous step
$signedUrl = "SIGNED_URL";
$filePath = "LOCAL_FILE_PATH";

uploadFileToSignedUrl($signedUrl, $filePath);
?>

using System;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string signedUrl = "SIGNED_URL"; // Replace with your signed URL
        string filePath = "LOCAL_FILE_PATH"; // Replace with your file path

        try
        {
            await UploadFileToSignedUrl(signedUrl, filePath);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error uploading file: " + ex.Message);
        }
    }

    static async Task UploadFileToSignedUrl(string signedUrl, string filePath)
    {
        using (var client = new HttpClient())
        using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        using (var content = new StreamContent(fileStream))
        {
            content.Headers.Add("Content-Type", "video/mp4");

            var response = await client.PutAsync(signedUrl, content);

            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("File upload successful: " + response.StatusCode);
            }
            else
            {
                Console.WriteLine("File upload failed: " + response.StatusCode);
            }
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;
import java.io.IOException;
import java.nio.file.Files;

public class FileUploader {

    public static void main(String[] args) {
        String signedUrl = "SIGNED_URL"; // Replace with your signed URL
        String filePath = "LOCAL_FILE_PATH"; // Replace with your file path

        try {
            uploadFileToSignedUrl(signedUrl, filePath);
        } catch (IOException | InterruptedException e) {
            System.out.println("Error uploading file: " + e.getMessage());
        }
    }

    private static void uploadFileToSignedUrl(String signedUrl, String filePath) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(signedUrl))
                .header("Content-Type", "image/jpg")
                .PUT(BodyPublishers.ofFile(Path.of(filePath)))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            System.out.println("File upload successful: " + response.statusCode());
        } else {
            System.out.println("File upload failed: " + response.statusCode());
        }
    }
}