Object Storage Service:Upload a file using a signed URL (C# SDK V1)

Précautions

• Cette rubrique utilise le point de terminaison public de la région Chine (Hangzhou). Pour accéder à OSS depuis d'autres services Alibaba Cloud situés dans la même région, privilégiez un point de terminaison interne. Pour obtenir la liste des régions et des points de terminaison pris en charge, consultez Régions et points de terminaison.

• Les exemples fournis illustrent la lecture des identifiants d'accès à partir des variables d'environnement. Pour savoir comment configurer ces identifiants, reportez-vous à la section Configuration des identifiants d'accès (C# SDK V1).

• La génération d'une URL signée pour un téléversement nécessite l'autorisation oss:PutObject. Pour plus d'informations, consultez la page Attribution de politiques d'accès personnalisées à un utilisateur RAM.

  Remarque

  Lors de la création d'une URL signée, le SDK calcule une signature via un algorithme spécifique en s'appuyant sur la clé stockée localement, puis l'ajoute à l'URL pour en garantir la validité et la sécurité. Ces opérations de calcul et de construction de l'URL s'exécutent côté client, sans envoyer de requête réseau au serveur. Par conséquent, l'appelant n'a pas besoin d'autorisations particulières pour générer l'URL signée. Cependant, afin que les tiers puissent effectuer les opérations autorisées par cette URL, assurez-vous que l'entité appelant l'API de génération dispose bien des permissions requises.

• Les exemples présentés reposent sur une URL signée V4, dont la durée de validité maximale est de 7 jours. Pour en savoir plus, consultez la documentation relative à la Version 4 de la signature (recommandée).

• Si l'URL signée générée à partir des exemples ci-dessous contient un signe plus (+), elle risque de devenir inaccessible. Pour résoudre ce problème, remplacez le signe plus (+) par %2B dans l'URL.

• Pour générer une URL signée utilisant le protocole HTTPS, configurez le protocole de communication du point de terminaison sur HTTPS.

Procédure

La procédure suivante détaille l'utilisation d'une URL signée avec la méthode PUT pour téléverser un fichier :

Exemples de code

1. Générer une URL signée pour un téléversement

   using Aliyun.OSS;
   using Aliyun.OSS.Common;
   // Specify the Endpoint for the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com.
   var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
   // Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
   var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
   var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
   // Specify the bucket name, for example, examplebucket.
   var bucketName = "examplebucket";
   // Specify the full path of the object. The full path does not include the bucket name. For example, exampledir/exampleobject.txt.
   var objectName = "exampledir/exampleobject.txt";
   var objectContent = "More than just cloud.";
   // Specify the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou.
   const string region = "cn-hangzhou";
   
   // Create a ClientConfiguration instance and modify the default parameters as needed.
   var conf = new ClientConfiguration();
   
   // Set the signature version to V4.
   conf.SignatureVersion = SignatureVersion.V4;
   
   // Create an OssClient instance.
   var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
   client.SetRegion(region);
   try
   {
       // Generate a signed URL.
       var generatePresignedUriRequest = new GeneratePresignedUriRequest(bucketName, objectName, SignHttpMethod.Put)
       {
           // Set the expiration time of the signed URL. The default value is 3600 seconds.
           Expiration = DateTime.Now.AddHours(1),
       };
       var signedUrl = client.GeneratePresignedUri(generatePresignedUriRequest);
   }
   catch (OssException ex)
   {
       Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
           ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
   }
   catch (Exception ex)
   {
       Console.WriteLine("Failed with error info: {0}", ex.Message);
   }

2. Téléverser un fichier par un autre utilisateur à l'aide de l'URL pré-signée pour la requête PUT.

   curl

   curl -X PUT -T /path/to/local/file "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

   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";
   
           try {
               HttpPut put = new HttpPut(signedUrl.toString());
               System.out.println(put);
               HttpEntity entity = new FileEntity(new File(pathName));
               put.setEntity(entity);
               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 (
   	"fmt"
   	"io"
   	"net/http"
   	"os"
   )
   
   func uploadFile(signedUrl, filePath string) error {
   	// Open the file.
   	file, err := os.Open(filePath)
   	if err != nil {
   		return fmt.Errorf("Unable to open file: %w", err)
   	}
   	defer file.Close()
   
   	// Create a new HTTP client.
   	client := &http.Client{}
   
   	// Create a PUT request.
   	req, err := http.NewRequest("PUT", signedUrl, file)
   	if err != nil {
   		return fmt.Errorf("Failed to create request: %w", err)
   	}
   
   	// Send the request.
   	resp, err := client.Do(req)
   	if err != nil {
   		return fmt.Errorf("Failed to send request: %w", err)
   	}
   	defer resp.Body.Close()
   
   	// Read the response.
   	body, err := io.ReadAll(resp.Body)
   	if err != nil {
   		return fmt.Errorf("Failed to read response: %w", err)
   	}
   
   	fmt.Printf("Status code returned for the upload: %d\n", resp.StatusCode)
   	if resp.StatusCode == 200 {
   		fmt.Println("Upload successful using network library.")
   	}
   	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"
   
   	err := uploadFile(signedUrl, filePath)
   	if err != nil {
   		fmt.Println("An error occurred:", err)
   	}
   }
   

   python

   import requests
   
   def upload_file(signed_url, file_path):
       try:
           # Open the file.
           with open(file_path, 'rb') as file:
               # Send a PUT request to upload the file.
               response = requests.put(signed_url, data=file)
        
           print(f"Status code returned for the upload: {response.status_code}")
           if response.status_code == 200:
               print("Upload successful using network library.")
           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 project path of the sample program by default.
       file_path = "C:\\Users\\demo.txt"
   
       upload_file(signed_url, file_path)
   

   Node.js

   Important

   Si vous rencontrez une erreur de non-correspondance de signature 403 lors du téléversement d'un fichier avec Node.js, cela provient généralement du fait que l'en-tête de requête Content-Type est défini explicitement dans la demande de téléversement, alors qu'il n'était pas inclus lors de la génération de l'URL pré-signée. Cette divergence entraîne un échec de la vérification de la signature. Pour corriger le problème, ne définissez pas l'en-tête Content-Type dans la requête de téléversement ou spécifiez-le lors de la création de l'URL pré-signée.

   const fs = require('fs');
   const axios = require('axios');
   
   async function uploadFile(signedUrl, filePath) {
       try {
           // Create a read stream.
           const fileStream = fs.createReadStream(filePath);
   
           // Send a PUT request to upload the file.
           const response = await axios.put(signedUrl, fileStream);
   
           console.log(`Status code returned for the upload: ${response.status}`);
           if (response.status === 200) {
               console.log('Upload successful using network library.');
           }
           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 project path of the sample program by default.
       const filePath = 'C:\\Users\\demo.txt';
   
       await uploadFile(signedUrl, filePath);
   })();

   browser.js

   Important

   Une erreur de non-correspondance de signature 403 lors d'un téléversement avec Browser.js survient souvent parce que le navigateur ajoute automatiquement l'en-tête de requête Content-Type, lequel n'avait pas été inclus lors de la génération de l'URL pré-signée. Cette incompatibilité provoque l'échec de la vérification de la signature. Pour y remédier, vous devez impérativement spécifier l'en-tête Content-Type au moment de créer 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</h1>
   
       <!-- Select a file -->
       <input type="file" id="fileInput" />
       <button id="uploadButton">Upload File</button>
   
       <script>
           // Replace this with the presigned URL generated in Step 1.
           const signedUrl = "<signedUrl>"; 
   
           document.getElementById('uploadButton').addEventListener('click', async () => {
               const fileInput = document.getElementById('fileInput');
               const file = fileInput.files[0];
   
               if (!file) {
                   alert('Please select a file to upload.');
                   return;
               }
   
               try {
                   await upload(file, signedUrl);
                   alert('File uploaded successfully!');
               } catch (error) {
                   console.error('Error during upload:', error);
                   alert('Upload failed: ' + error.message);
               }
           });
   
           /**
            * Upload the file to OSS.
            * @param {File} file - The file to upload.
            * @param {string} presignedUrl - The presigned URL.
            */
           const upload = async (file, presignedUrl) => {
               const response = await fetch(presignedUrl, {
                   method: 'PUT',
                   body: file,  // Upload the entire file directly.
               });
   
               if (!response.ok) {
                   throw new Error(`Upload failed, status: ${response.status}`);
               }
   
               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;
   
   // 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>
   
   void uploadFile(const std::string& signedUrl, const std::string& filePath) {
       CURL *curl;
       CURLcode res;
   
       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;
           }
   
           // Get the file size.
           fseek(file, 0, SEEK_END);
           long fileSize = ftell(file);
           fseek(file, 0, SEEK_SET);
   
           // Set the file size.
           curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
   
           // Set the input file handle.
           curl_easy_setopt(curl, CURLOPT_READDATA, file);
   
           // Execute the request.
           res = curl_easy_perform(curl);
   
           if (res != CURLE_OK) {
               std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
           } else {
               long httpCode = 0;
               curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
               std::cout << "Status code returned for the upload: " << httpCode << std::endl;
   
               if (httpCode == 200) {
                   std::cout << "Upload successful using network library." << std::endl;
               }
           }
   
           // Close the file.
           fclose(file);
   
           // Clean up.
           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";
   
       uploadFile(signedUrl, filePath);
   
       return 0;
   }
   

   Android

   package com.example.signurlupload;
   
   import android.os.AsyncTask;
   import android.util.Log;
   
   import java.io.DataOutputStream;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.net.HttpURLConnection;
   import java.net.URL;
   
   public class SignUrlUploadActivity {
   
       private static final String TAG = "SignUrlUploadActivity";
   
       public void uploadFile(String signedUrl, String filePath) {
           new UploadTask().execute(signedUrl, filePath);
       }
   
       private class UploadTask extends AsyncTask<String, Void, String> {
   
           @Override
           protected String doInBackground(String... params) {
               String signedUrl = params[0];
               String filePath = params[1];
   
               HttpURLConnection connection = null;
               DataOutputStream dos = null;
               FileInputStream fis = null;
   
               try {
                   URL url = new URL(signedUrl);
                   connection = (HttpURLConnection) url.openConnection();
                   connection.setRequestMethod("PUT");
                   connection.setDoOutput(true);
                   connection.setRequestProperty("Content-Type", "application/octet-stream");
   
                   fis = new FileInputStream(filePath);
                   dos = new DataOutputStream(connection.getOutputStream());
   
                   byte[] buffer = new byte[1024];
                   int length;
   
                   while ((length = fis.read(buffer)) != -1) {
                       dos.write(buffer, 0, length);
                   }
   
                   dos.flush();
                   dos.close();
                   fis.close();
   
                   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.");
                   }
   
                   return "Upload complete. Status code: " + responseCode;
   
               } catch (IOException e) {
                   e.printStackTrace();
                   return "Upload failed: " + e.getMessage();
               } finally {
                   if (connection != null) {
                       connection.disconnect();
                   }
               }
           }
   
           @Override
           protected void onPostExecute(String result) {
               Log.d(TAG, result);
           }
       }
   
       public static void main(String[] args) {
           SignUrlUploadActivity activity = new SignUrlUploadActivity();
           // 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 filePath = "C:\\Users\\demo.txt";
           activity.uploadFile(signedUrl, filePath);
       }
   }
   

FAQ