Object Storage Service:Utiliser une URL pré-signée pour télécharger un objet à l'aide du SDK OSS pour Python 1.0

1. Le propriétaire de l'objet génère une URL présignée qui contient des en-têtes de requête spécifiques et des métadonnées utilisateur, et qui autorise les requêtes HTTP PUT.

   # -*- coding: utf-8 -*-
   import oss2
   from oss2.credentials import EnvironmentVariableCredentialsProvider
   
   # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
   auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
   
   # Specify the region in which the bucket is located. Example: cn-hangzhou. This parameter is required if you use the V4 signature algorithm.
   region = "cn-hangzhou"
   
   # Specify the name of the bucket. 
   bucket = oss2.Bucket(auth, endpoint, "yourBucketName", region=region)
   
   # Specify the full path of the object. Example: exampledir/exampleobject.txt. Do not include the bucket name in the full path. 
   object_name = 'exampledir/exampleobject.txt'
   
   # Specify request headers. 
   headers = dict()
   # Specify the Content-Type header. 
   headers['Content-Type'] = 'text/plain; charset=utf8'
   # Specify the storage class of the object. 
   headers["x-oss-storage-class"] = "Standard"
   
   # Specify user metadata.
   metadata = {'key1': 'value1', 'key2': 'value2'}
   # Add the x-oss-meta- prefix to the metadata key.
   for key, value in metadata.items():
       headers[f'x-oss-meta-{key}'] = value
   
   # Generate a presigned URL that is used to upload a local file. Set the validity period of the presigned URL to 60 seconds. 
   # By default, OSS identifies the forward slashes (/) in the full path of an object as escape characters when a presigned URL is generated. Therefore, you cannot directly use the presigned URL. 
   # Set the slash_safe parameter to True. This way, OSS does not identify forward slashes (/) in the full path of the object as escape characters. In this case, you can directly use the presigned URL. 
   url = bucket.sign_url('PUT', object_name, 60, slash_safe=True, headers=headers)
   print('The presigned URL:', url)

2. Un utilisateur utilise l'URL présignée qui autorise les requêtes HTTP PUT pour charger un objet.

   curl

   curl -X PUT \
        -H "Content-Type: text/plain;charset=utf8" \
        -H "x-oss-storage-class: Standard" \
        -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=LTAI****************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a******************************************************"

   Java

   package com.aliyun.sample;
   
   import com.aliyun.oss.internal.OSSHeaders;
   import com.aliyun.oss.model.StorageClass;
   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 authorized URL.
           URL signedUrl = new URL("<signedUrl>");
   
           // Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the project path of the sample program by default.
           String pathName = "C:\\Users\\demo.txt";
   
           // Set the request headers. The request header information must be the same as the information used when the URL was 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 ContentType.
           headers.put(OSSHeaders.CONTENT_TYPE, "text/plain;charset=utf8");
   
           // Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was 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 you set header parameters, such as user metadata and storage class, when you generate the presigned URL, you must also send these parameters to the server when you use the presigned URL to upload the file. A signature error is reported if the parameters sent to the server are inconsistent with the signed parameters.
               for(Map.Entry<String, String> header: headers.entrySet()){
                   put.addHeader(header.getKey(), header.getValue());
               }
               for(Map.Entry<String, String> meta: userMetadata.entrySet()){
                   // If you use userMeta, the SDK internally adds the 'x-oss-meta-' prefix. When you use other methods to generate a presigned URL for an upload, you must also add the 'x-oss-meta-' prefix to the userMeta.
                   put.addHeader("x-oss-meta-"+meta.getKey(), meta.getValue());
               }
   
               httpClient = HttpClients.createDefault();
   
               response = httpClient.execute(put);
   
               System.out.println("Status code returned for the upload:"+response.getStatusLine().getStatusCode());
               if(response.getStatusLine().getStatusCode() == 200){
                   System.out.println("Upload successful using network library.");
               }
               System.out.println(response.toString());
           } catch (Exception e){
               e.printStackTrace();
           } finally {
               if (response != null) {
                   response.close();
               }
               if (httpClient != null) {
                   httpClient.close();
               }
           }
       }
   }

   Go

   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 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
   	}
   
   	// Set the request headers.
   	for key, value := range headers {
   		req.Header.Set(key, value)
   	}
   
   	// Set the custom 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("Status code returned for the upload: %d\n", resp.StatusCode)
   	if resp.StatusCode == 200 {
   		fmt.Println("Upload successful using network library.")
   	} else {
   		fmt.Println("Upload failed.")
   	}
   	body, _ := ioutil.ReadAll(resp.Body)
   	fmt.Println(string(body))
   
   	return nil
   }
   
   func main() {
   	// Replace <signedUrl> with the authorized URL.
   	signedUrl := "<signedUrl>"
   
   	// Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the project path of the sample program by default.
   	filePath := "C:\\Users\\demo.txt"
   
   	// Set the request headers. The request header information must be the same as the information used when the URL was generated.
   	headers := map[string]string{
   		"Content-Type": "text/plain;charset=utf8",
   		"x-oss-storage-class": "Standard",
   	}
   
   	// Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was 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)
   	}
   }
   

   Python

   import requests
   from requests.auth import HTTPBasicAuth
   import os
   
   def upload_file(signed_url, file_path, headers=None, metadata=None):
       """
       Use a presigned URL to upload a file to OSS.
   
       :param signed_url: The presigned URL.
       :param file_path: The full path of the file to upload.
       :param headers: Optional. Custom HTTP headers.
       :param metadata: Optional. Custom metadata.
       :return: None
       """
       if not headers:
           headers = {}
       if not metadata:
           metadata = {}
   
       # Update headers and add 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"Status code returned for the upload: {response.status_code}")
               if response.status_code == 200:
                   print("Upload successful using 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 authorized URL.
       signed_url = "<signedUrl>"
      
       # Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the directory where the script is located by default.
       file_path = "C:\\Users\\demo.txt"
   
       # Set the request headers. The request header information must be the same as the information used when the URL was generated.
       headers = {
            "Content-Type": "text/plain;charset=utf8",
            "x-oss-storage-class": "Standard"
       }
   
       # Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was generated.
       metadata = {
            "key1": "value1",
            "key2": "value2"
       }
   
       upload_file(signed_url, file_path, headers, metadata)
   

   Node.js

   const fs = require('fs');
   const axios = require('axios');
   
   async function uploadFile(signedUrl, filePath, headers = {}, metadata = {}) {
       try {
           // Update headers and add 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 a PUT request.
           const response = await axios.put(signedUrl, fileStream, {
               headers: headers
           });
   
           console.log(`Status code returned for the upload: ${response.status}`);
           if (response.status === 200) {
               console.log("Upload successful using network library.");
           } else {
               console.log("Upload failed.");
           }
           console.log(response.data);
       } catch (error) {
           console.error(`An error occurred: ${error.message}`);
       }
   }
   
   // Main function.
   (async () => {
       // Replace <signedUrl> with the authorized URL.
       const signedUrl = "<signedUrl>";
   
       // Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the directory where the script is located by default.
       const filePath = "C:\\Users\\demo.txt";
   
       // Set the request headers. The request header information must be the same as the information used when the URL was generated.
       const headers = {
            "Content-Type": "text/plain;charset=utf8",
            "x-oss-storage-class": "Standard"
       };
   
       // Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was generated.
       const metadata = {
            "key1": "value1",
            "key2": "value2"
       };
   
       await uploadFile(signedUrl, filePath, headers, metadata);
   })();
   

   Browser.js

   Important

   Si vous rencontrez une erreur d'inadéquation de signature 403 lors du chargement d'un fichier avec Browser.js, cela est généralement dû au fait que le navigateur ajoute automatiquement l'en-tête de requête Content-Type, qui n'était pas inclus lors de la génération de l'URL présignée. Cette inadéquation entraîne un échec de la vérification de la signature. Pour résoudre ce problème, vous devez spécifier l'en-tête de requête Content-Type lors de la génération de l'URL présignée.

   <!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 (Java SDK)</h1>
   
       <input type="file" id="fileInput" />
       <button id="uploadButton">Upload File</button>
   
       <script>
           // Replace this with the actual presigned URL.
           const signedUrl = "<signedUrl>"; 
   
           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 {
                   alert('Please select a file to upload.');
               }
           });
   
           const upload = async (file, presignedUrl) => {
               const headers = {
                   "Content-Type": "text/plain;charset=utf8",
                   'x-oss-storage-class': 'Standard',
                   'x-oss-meta-key1': 'value1',
                   'x-oss-meta-key2': 'value2'
               };
   
               const response = await fetch(presignedUrl, {
                   method: 'PUT',
                   headers: headers,
                   body: file
               });
   
               if (!response.ok) {
                   throw new Error(`Upload failed, status: ${response.status}`);
               }
   
               alert('File uploaded successfully');
               console.log('File uploaded successfully');
           };
       </script>
   </body>
   </html>

   C#

   using System.Net.Http.Headers;
   
   // Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the project path of the sample program by default.
   var filePath = "C:\\Users\\demo.txt";
   // Replace <signedUrl> with the authorized URL.
   var presignedUrl = "<signedUrl>";
   
   // Create an HTTP client and open the local file stream.
   using var httpClient = new HttpClient(); 
   using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
   using var content = new StreamContent(fileStream);
               
   // Create a PUT request.
   var request = new HttpRequestMessage(HttpMethod.Put, presignedUrl);
   request.Content = content;
   
   // If you set header parameters, such as user metadata and storage class, when you generate the presigned URL, you must also send these parameters to the server when you use the presigned URL to upload the file. A signature error is reported if the parameters sent to the server are inconsistent with the signed parameters.
   // Set the request headers. The request header information must be the same as the information used when the URL was generated.
   request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain") { CharSet = "utf8" };  // Specify the ContentType.       
   // Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was generated.
   request.Content.Headers.Add("x-oss-meta-key1", "value1");
   request.Content.Headers.Add("x-oss-meta-key2", "value2");
   // Specify the storage class of the object.
   request.Content.Headers.Add("x-oss-storage-class", "Standard");
   
   // Print the request headers.
   Console.WriteLine("Request headers:");
   foreach (var header in request.Content.Headers)
   {
       Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
   }
   
   // Send the request.
   var response = await httpClient.SendAsync(request);
   
   // Process the response.
   if (response.IsSuccessStatusCode)
   {
       Console.WriteLine($"Upload successful! Status code: {response.StatusCode}");
       Console.WriteLine("Response headers:");
       foreach (var header in response.Headers)
       {
           Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
       }
   }
   else
   {
       string responseContent = await response.Content.ReadAsStringAsync();
       Console.WriteLine($"Upload failed! Status code: {response.StatusCode}");
       Console.WriteLine("Response content: " + responseContent);
   }

   C++

   #include <iostream>
   #include <fstream>
   #include <curl/curl.h>
   #include <map>
   #include <string>
   
   // Callback function to handle 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) {
           // Set the 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 file.
           FILE* file = fopen(filePath.c_str(), "rb");
           if (!file) {
               std::cerr << "Unable to open file: " << filePath << std::endl;
               return;
           }
   
           // Set the file size.
           fseek(file, 0, SEEK_END);
           long fileSize = ftell(file);
           rewind(file);
   
           // Set the file read callback.
           curl_easy_setopt(curl, CURLOPT_READDATA, file);
           curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
   
           // Set the 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);
   
           // Set the response handling callback.
           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 << "Status code returned for the upload: " << responseCode << std::endl;
               if (responseCode == 200) {
                   std::cout << "Upload successful using 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 authorized URL.
       std::string signedUrl = "<signedUrl>";
   
       // Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the project path of the sample program by default.
       std::string filePath = "C:\\Users\\demo.txt";
   
       // Set the request headers. The request header information must be the same as the information used when the URL was generated.
       std::map<std::string, std::string> headers = {
            {"Content-Type", "text/plain;charset=utf8"},
            {"x-oss-storage-class", "Standard"}
       };
   
       // Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was generated.
       std::map<std::string, std::string> metadata = {
            {"key1", "value1"},
            {"key2", "value2"}
       };
   
       uploadFile(signedUrl, filePath, headers, metadata);
   
       return 0;
   }
   

   Android

   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 authorized URL.
           String signedUrl = "<signedUrl>";
   
           // Specify the full path of the local file. If you do not specify a local path, the file is uploaded from the project path of the sample program by default.
           String pathName = "/storage/emulated/0/demo.txt";
   
           // Set the request headers. The request header information must be the same as the information used when the URL was generated.
           Map<String, String> headers = new HashMap<>();
           headers.put("Content-Type", "text/plain;charset=utf8");
           headers.put("x-oss-storage-class", "Standard");
   
           // Set the custom user metadata. The custom user metadata must be the same as the information used when the URL was 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);
   
                   // Set the request headers.
                   for (Entry<String, String> header : headers.entrySet()) {
                       connection.setRequestProperty(header.getKey(), header.getValue());
                   }
   
                   // Set the custom 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();
   
                   // Get the response.
                   int responseCode = connection.getResponseCode();
                   Log.d(TAG, "Status code returned for the upload: " + responseCode);
                   if (responseCode == 200) {
                       Log.d(TAG, "Upload successful using 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, "Upload successful.", Toast.LENGTH_SHORT).show();
               } else {
                   Toast.makeText(SignUrlUploadActivity.this, "Upload failed.", Toast.LENGTH_SHORT).show();
               }
           }
       }
   }
   

Si le serveur reçoit la requête et vérifie la signature, le chargement du fichier ne sera pas interrompu.

Il n'est pas nécessaire de spécifier les en-têtes de requête et les métadonnées utilisateur. Ces paramètres sont facultatifs. Si vous ne les spécifiez pas, supprimez le code correspondant dans l'exemple ci-dessus.