Object Storage Service:Upload files using presigned URLs

curl -X PUT \
     -H "Content-Type: text/plain; charset=utf8" \
     -H "x-oss-meta-key1: value1" \
     -H "x-oss-meta-key2: value2" \
     -T "C:\\Users\\demo.txt" \
     "https://exampleobject.oss-cn-hangzhou.aliyuncs.com/exampleobject.txt?x-oss-date=20241112T083238Z&x-oss-expires=3599&x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-credential=LTAI5************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a939feb8d79a389572719f7e2939939936d0**********"

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.FileEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import java.io.*;
import java.net.URL;
import java.util.*;

public class SignUrlUpload {
    public static void main(String[] args) throws Throwable {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;

        // Replace <signedUrl> with the signed URL.
        URL signedUrl = new URL("<signedUrl>");

        // Specify the full path of the local file. If the path of the local file is not specified, the local file is uploaded from the path of the project to which the sample program belongs.
        String pathName = "C:\\Users\\demo.txt";

        // Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
        Map<String, String> headers = new HashMap<String, String>();
        /*// Specify the storage class of the object.
        headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
        // Specify the content type.
        headers.put(OSSHeaders.CONTENT_TYPE, "text/txt");*/

        // Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
        Map<String, String> userMetadata = new HashMap<String, String>();
        /*userMetadata.put("key1","value1");
        userMetadata.put("key2","value2");*/

        try {
            HttpPut put = new HttpPut(signedUrl.toString());
            System.out.println(put);
            HttpEntity entity = new FileEntity(new File(pathName));
            put.setEntity(entity);
            // If headers are specified when you generate a presigned URL, such as user metadata and storage class, make sure that the headers are included in the request when you upload the object by using the presigned URL. If the headers that are sent to the server for the signature calculation are different from the headers specified when the signed URL is generated, a signature error is reported.
            for(Map.Entry header: headers.entrySet()){
                put.addHeader(header.getKey().toString(),header.getValue().toString());
            }
            for(Map.Entry meta: userMetadata.entrySet()){
                // If userMeta is used, the x-oss-meta- prefix is added to userMeta. When you use other methods to generate a presigned URL to upload an object, you must also add the x-oss-meta- prefix to userMeta.
                put.addHeader("x-oss-meta-"+meta.getKey().toString(), meta.getValue().toString());
            }

            httpClient = HttpClients.createDefault();

            response = httpClient.execute(put);

            System.out.println("Upload status code:"+response.getStatusLine().getStatusCode());
            if(response.getStatusLine().getStatusCode() == 200){
                System.out.println("Upload successfully using the network library");
            }
            System.out.println(response.toString());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            response.close();
            httpClient.close();
        }
    }
}       

import requests
from requests.auth import HTTPBasicAuth
import os

def upload_file(signed_url, file_path, headers=None, metadata=None):
    """
    Use the pre-signed URL to upload an object to OSS.

    :param signed_url: Specify the pre-signed URL.
    :param file_path: Specify the full path of the local file that you want to upload.
    :param headers: Optional. Specify the request headers.
    :param metadata: Optional. Specify the user metadata.
    :return: None
    """
    if not headers:
        headers = {}
    if not metadata:
        metadata = {}

    # Update the request headers and specify the metadata prefix
    for key, value in metadata.items():
        headers[f'x-oss-meta-{key}'] = value

    try:
        with open(file_path, 'rb') as file:
            response = requests.put(signed_url, data=file, headers=headers)
            print(f"Upload status code:{response.status_code}")
            if response.status_code == 200:
                print("Upload successfully using the network library")
            else:
                print("Upload failed")
            print(response.text)
    except Exception as e:
        print(f"An error occurred:{e}")

if __name__ == "__main__":
    // Replace <signedUrl> with the signed URL.
    signed_url = "<signedUrl>"
   
    // Specify the full path of the local file. If you do not specify the full path, the local file is uploaded from the directory in which the script is stored.
    file_path = "C:\\Users\\demo.txt"

    // Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
    headers = {
         "Content-Type": "text/plain; charset=utf8",
         "x-oss-storage-class": "Standard"
    }

    // Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
    metadata = {
         "key1": "value1",
         "key2": "value2"
    }

    upload_file(signed_url, file_path, headers, metadata)

const fs = require('fs');
const axios = require('axios');

async function uploadFile(signedUrl, filePath, headers = {}, metadata = {}) {
    try {
        // Update the request headers and specify the metadata prefix
        for (const [key, value] of Object.entries(metadata)) {
            headers[`x-oss-meta-${key}`] = value;
        }

        // Read the file stream
        const fileStream = fs.createReadStream(filePath);

        // Send the PUT request
        const response = await axios.put(signedUrl, fileStream, {
            headers: headers
        });

        console.log(`Upload status code:${response.status}`);
        if (response.status === 200) {
            console.log("Upload successfully using the network library");
        } else {
            console.log("Upload failed");
        }
        console.log(response.data);
    } catch (error) {
        console.error(`An error occurred:${error.message}`);
    }
}

// Specify the main function
(async () => {
    // Replace <signedUrl> with the signed URL.
    const signedUrl = "<signedUrl>";

    // Specify the full path of the local file. If you do not specify the full path, the local file is uploaded from the directory in which the script is stored.
    const filePath = "C:\\Users\\demo.txt";

    // Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
    const headers = {
        // "Content-Type": "text/txt",
        // "x-oss-storage-class": "Standard"
    };

    // Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
    const metadata = {
        // "key1": "value1",
        // "key2": "value2"
    };

    await uploadFile(signedUrl, filePath, headers, metadata);
})();

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>File Upload Example</title>
</head>
<body>
    <h1>File Upload Example</h1>

    <input type="file" id="fileInput" />
    <button id="uploadButton">Upload File</button>

    <script>
        // Replace this with the actual presigned URL
        const signedUrl = "<signedUrl>"; 

        // Specify the content type, storage class, and metadata
        const contentType = 'text/plain';

        const storageClass = 'Standard';

        const metadata = {
            'x-oss-meta-key1': 'value1',
            'x-oss-meta-key2': 'value2'
        };

        document.getElementById('uploadButton').addEventListener('click', async () => {
            const fileInput = document.getElementById('fileInput');
            const file = fileInput.files[0];

            if (file) {
                try {
                    await upload(file, signedUrl);
                } catch (error) {
                    console.error('Error during upload:', error);
                    alert('Upload failed: ' + error.message);
                }
            } else {
                console.error('Please select a file');
                alert('Please select a file to upload.');
            }
        });

        const upload = async (file, presignedUrl) => {
            const chunkSize = 1024 * 1024;
            let start = 0;
            let end = chunkSize;

            while (start < file.size) {
                const chunk = file.slice(start, end);
                
                const headers = {
                    'Content-Type': contentType,
                    'x-oss-storage-class':storageClass,
                    ...metadata
                };
                
                const response = await fetch(presignedUrl, {
                    method: 'PUT',
                    headers: headers,
                    body: chunk
                });

                if (!response.ok) {
                    throw new Error(`Upload failed for chunk, status: ${response.status}`);
                }

                console.log('Chunk uploaded successfully'); 
                start = end;
                end = start + chunkSize;
            }

            console.log('File uploaded successfully'); 
        };
    </script>
</body>
</html>

#include <iostream>
#include <fstream>
#include <curl/curl.h>
#include <map>
#include <string>

// Specify the callback function that is used to process the HTTP response
size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
    size_t totalSize = size * nmemb;
    output->append((char*)contents, totalSize);
    return totalSize;
}

void uploadFile(const std::string& signedUrl, const std::string& filePath, const std::map<std::string, std::string>& headers, const std::map<std::string, std::string>& metadata) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if (curl) {
        // Specify the signed URL
        curl_easy_setopt(curl, CURLOPT_URL, signedUrl.c_str());

        // Set the request method to PUT
        curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

        // Open the local file
        FILE* file = fopen(filePath.c_str(), "rb");
        if (!file) {
            std::cerr << "Unable to open the local file: " << filePath << std::endl;
            return;
        }

        // Specify the size of the local file
        fseek(file, 0, SEEK_END);
        long fileSize = ftell(file);
        rewind(file);

        // Configure a callback when you read the object
        curl_easy_setopt(curl, CURLOPT_READDATA, file);
        curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);

        // Specify request headers
        struct curl_slist* chunk = nullptr;
        for (const auto& header : headers) {
            std::string headerStr = header.first + ": " + header.second;
            chunk = curl_slist_append(chunk, headerStr.c_str());
        }
        for (const auto& meta : metadata) {
            std::string metaStr = "x-oss-meta-" + meta.first + ": " + meta.second;
            chunk = curl_slist_append(chunk, metaStr.c_str());
        }
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);

        // Specify the callback function that is used to process the response
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        // Execute the request
        res = curl_easy_perform(curl);

        // Check the response
        if (res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            long responseCode;
            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
            std::cout << "Upload status code: " << responseCode << std::endl;
            if (responseCode == 200) {
                std::cout << "Upload successfully using the network library" << std::endl;
            } else {
                std::cout << "Upload failed" << std::endl;
            }
            std::cout << readBuffer << std::endl;
        }

        // Clean up
        fclose(file);
        curl_slist_free_all(chunk);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
}

int main() {
    // Replace <signedUrl> with the signed URL.
    std::string signedUrl = "<signedUrl>";

    // Specify the full path of the local file. If the path of the local file is not specified, the local file is uploaded from the path of the project to which the sample program belongs.
    std::string filePath = "C:\\Users\\demo.txt";

    // Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
    std::map<std::string, std::string> headers = {
        // {"Content-Type", "text/txt"},
        // {"x-oss-storage-class", "Standard"}
    };

    // Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
    std::map<std::string, std::string> metadata = {
        // {"key1", "value1"},
        // {"key2", "value2"}
    };

    uploadFile(signedUrl, filePath, headers, metadata);

    return 0;
}

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
)

func uploadFile(signedUrl string, filePath string, headers map[string]string, metadata map[string]string) error {
	// Open the local file
	file, err := os.Open(filePath)
	if err != nil {
		return err
	}
	defer file.Close()

	// Read the file content
	fileBytes, err := ioutil.ReadAll(file)
	if err != nil {
		return err
	}

	// Create a request
	req, err := http.NewRequest("PUT", signedUrl, bytes.NewBuffer(fileBytes))
	if err != nil {
		return err
	}

	// Specify request headers
	for key, value := range headers {
		req.Header.Set(key, value)
	}

	// Specify user metadata
	for key, value := range metadata {
		req.Header.Set(fmt.Sprintf("x-oss-meta-%s", key), value)
	}

	// Send the request
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	// Process the response
	fmt.Printf("Upload status code: %d\n", resp.StatusCode)
	if resp.StatusCode == 200 {
		fmt.Println("Upload successfully using the network library")
	} else {
		fmt.Println("Upload failed")
	}
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))

	return nil
}

func main() {
	// Replace <signedUrl> with the signed URL.
	signedUrl := "<signedUrl>"

	// Specify the full path of the local file. If the path of the local file is not specified, the local file is uploaded from the path of the project to which the sample program belongs.
	filePath := "C:\\Users\\demo.txt"

	// Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
	headers := map[string]string{
		// "Content-Type": "text/txt",
		// "x-oss-storage-class": "Standard",
	}

	// Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
	metadata := map[string]string{
		// "key1": "value1",
		// "key2": "value2",
	}

	err := uploadFile(signedUrl, filePath, headers, metadata)
	if err != nil {
		fmt.Printf("An error occurred:%v\n", err)
	}
}

import android.os.AsyncTask;
import android.util.Log;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class SignUrlUploadActivity extends AppCompatActivity {

    private static final String TAG = "SignUrlUploadActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Replace <signedUrl> with the signed URL.
        String signedUrl = "<signedUrl>";

        // Specify the full path of the local file. If the path of the local file is not specified, the local file is uploaded from the path of the project to which the sample program belongs.
        String pathName = "/storage/emulated/0/demo.txt";

        // Specify request headers. Make sure that the values of the request headers are the same as that of the request headers when the signed URL is generated.
        Map<String, String> headers = new HashMap<>();
        // headers.put("Content-Type", "text/txt");
        // headers.put("x-oss-storage-class", "Standard");

        // Specify user metadata. Make sure that the user metadata is the same as the user metadata when the signed URL is generated.
        Map<String, String> userMetadata = new HashMap<>();
        // userMetadata.put("key1", "value1");
        // userMetadata.put("key2", "value2");

        new UploadTask().execute(signedUrl, pathName, headers, userMetadata);
    }

    private class UploadTask extends AsyncTask<Object, Void, Integer> {
        @Override
        protected Integer doInBackground(Object... params) {
            String signedUrl = (String) params[0];
            String pathName = (String) params[1];
            Map<String, String> headers = (Map<String, String>) params[2];
            Map<String, String> userMetadata = (Map<String, String>) params[3];

            try {
                URL url = new URL(signedUrl);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("PUT");
                connection.setDoOutput(true);
                connection.setUseCaches(false);

                // Specify request headers
                for (Entry<String, String> header : headers.entrySet()) {
                    connection.setRequestProperty(header.getKey(), header.getValue());
                }

                // Specify user metadata
                for (Entry<String, String> meta : userMetadata.entrySet()) {
                    connection.setRequestProperty("x-oss-meta-" + meta.getKey(), meta.getValue());
                }

                // Read the file
                File file = new File(pathName);
                FileInputStream fileInputStream = new FileInputStream(file);
                DataOutputStream dos = new DataOutputStream(connection.getOutputStream());

                byte[] buffer = new byte[1024];
                int count;
                while ((count = fileInputStream.read(buffer)) != -1) {
                    dos.write(buffer, 0, count);
                }

                fileInputStream.close();
                dos.flush();
                dos.close();

                // Obtain the response
                int responseCode = connection.getResponseCode();
                Log.d(TAG, "Upload status code:" + responseCode);
                if (responseCode == 200) {
                    Log.d(TAG, "Upload successfully using the network library");
                } else {
                    Log.d(TAG, "Upload failed");
                }

                InputStream is = connection.getInputStream();
                byte[] responseBuffer = new byte[1024];
                StringBuilder responseStringBuilder = new StringBuilder();
                while ((count = is.read(responseBuffer)) != -1) {
                    responseStringBuilder.append(new String(responseBuffer, 0, count));
                }
                Log.d(TAG, responseStringBuilder.toString());

                return responseCode;
            } catch (IOException e) {
                e.printStackTrace();
                return -1;
            }
        }

        @Override
        protected void onPostExecute(Integer result) {
            super.onPostExecute(result);
            if (result == 200) {
                Toast.makeText(SignUrlUploadActivity.this, "Object uploaded", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(SignUrlUploadActivity.this, "Upload failed", Toast.LENGTH_SHORT).show();
            }
        }
    }
}