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

Precauções

• Este tópico usa o endpoint público da região China (Hangzhou). Para acessar o OSS a partir de outros serviços da Alibaba Cloud na mesma região, use um endpoint interno. Para obter detalhes sobre as regiões e endpoints compatíveis, consulte Regiões e endpoints.

• Os exemplos abaixo mostram como ler credenciais de acesso de variáveis de ambiente. Para mais informações sobre como configurar credenciais de acesso, consulte Configurar credenciais de acesso (C# SDK V1).

• Para gerar uma URL assinada para upload, você precisa da permissão oss:PutObject. Para mais informações, consulte Conceder políticas de acesso personalizadas a um usuário RAM.

  Nota

  Ao gerar uma URL assinada, o SDK usa a chave armazenada localmente para calcular uma assinatura com base em um algoritmo específico. Em seguida, o SDK anexa essa assinatura à URL para garantir sua validade e segurança. Essas operações de cálculo e construção da URL ocorrem no cliente, sem envio de requisições de rede ao servidor. Portanto, o chamador não precisa de permissões específicas apenas para gerar a URL assinada. No entanto, para garantir que terceiros executem operações nos recursos autorizados pela URL assinada, a entidade que chama a API para gerar a URL deve ter as permissões necessárias.

• Este tópico apresenta um exemplo de URL assinada V4. O período máximo de validade de uma URL assinada V4 é de 7 dias. Para mais informações, consulte Versão de Assinatura 4 (recomendada).

• Se uma URL assinada gerada pelos exemplos a seguir contiver um sinal de mais (+), ela poderá ficar inacessível. Para resolver esse problema, substitua o sinal de mais (+) na URL por %2B.

• Para gerar uma URL assinada que use o protocolo HTTPS, defina o protocolo de comunicação no Endpoint como HTTPS.

Procedimento

O procedimento a seguir mostra como usar uma URL assinada com o método PUT para fazer upload de um arquivo:

Exemplos de código

1. Gere uma URL assinada para upload

   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. Outro usuário faz upload de um arquivo usando a URL pré-assinada para a requisição 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

   Importante

   Se você encontrar um erro 403 de incompatibilidade de assinatura ao usar Node.js para fazer upload de um arquivo, geralmente isso ocorre porque o cabeçalho de requisição Content-Type foi definido explicitamente na requisição de upload, mas não foi incluído durante a geração da URL pré-assinada. Essa incompatibilidade causa falha na verificação da assinatura. Para resolver esse problema, não defina o cabeçalho de requisição Content-Type na requisição de upload ou especifique o cabeçalho de requisição Content-Type ao gerar a URL pré-assinada.

   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

   Importante

   Se você encontrar um erro 403 de incompatibilidade de assinatura ao usar Browser.js para fazer upload de um arquivo, geralmente isso ocorre porque o navegador adiciona automaticamente o cabeçalho de requisição Content-Type, e esse cabeçalho não foi incluído durante a geração da URL pré-assinada. Essa incompatibilidade causa falha na verificação da assinatura. Para resolver esse problema, especifique o cabeçalho de requisição Content-Type ao gerar a URL pré-assinada.

   <!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);
       }
   }
   

Perguntas frequentes