全部产品
Search

搜索本产品

    Object Storage Service：Callback Unggah

    文档中心

    Object Storage Service：Callback Unggah

    更新时间：Jul 06, 2025

    Saat sebuah objek diunggah, Object Storage Service (OSS) dapat memulai proses callback ke server aplikasi. Untuk mengonfigurasi callback unggah, Anda hanya perlu menambahkan parameter callback yang diperlukan ke permintaan unggah yang dikirim ke OSS.

    Skenario

    Skenario tipikal dari callback unggah adalah memberi otorisasi pada unggahan pihak ketiga. Anda dapat menyederhanakan logika klien dan menghemat sumber daya jaringan dengan menggunakan callback unggah. Gambar berikut menunjukkan cara kerja callback unggah.

    1. Klien menentukan callback unggah dalam permintaan unggah yang dikirim dari klien ke OSS.

    2. Setelah tugas unggah selesai, OSS mengirim permintaan HTTP untuk callback unggah ke server aplikasi. callbackUrl adalah URL publik dari server aplikasi.

    3. Server aplikasi menerima permintaan, yang menandakan bahwa unggahan telah selesai. Kemudian, server aplikasi melakukan operasi seperti memodifikasi database dan merespons permintaan yang dikirim dari OSS.

    4. Setelah OSS menerima respons, OSS mengembalikan hasil unggah ke klien.

    Saat OSS mengirim permintaan callback POST ke server aplikasi, OSS menyertakan parameter yang berisi informasi spesifik dalam badan permintaan POST.

    Parameter tersebut dibagi menjadi dua kategori: parameter yang ditentukan sistem, seperti yang digunakan untuk menentukan nama bucket dan nama objek, serta parameter kustom yang berisi informasi spesifik terkait logika aplikasi, seperti ID peminta.

    Catatan

    • Hanya unggahan sederhana (PutObject), unggahan formulir (PostObject), dan unggahan multipart (CompleteMultipartUpload) yang mendukung callback unggah.

    • Setelah objek diunggah ke OSS, OSS mengirim permintaan callback untuk memberi tahu server aplikasi tentang unggahan objek. Ini membantu server aplikasi untuk melakukan operasi selanjutnya seperti pembaruan data atau notifikasi. Objek yang diunggah disimpan di OSS terlepas dari apakah callback unggah berhasil atau gagal.

    Prosedur

    Menggunakan SDK OSS

    Berikut ini adalah contoh kode yang menunjukkan cara mengonfigurasi callback unggah dengan menggunakan SDK OSS untuk bahasa pemrograman umum. Untuk informasi lebih lanjut tentang cara mengonfigurasi callback unggah dengan menggunakan SDK OSS untuk bahasa pemrograman lainnya, lihat Ikhtisar.

    import com.aliyun.oss.ClientBuilderConfiguration;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.Callback;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;

import java.io.ByteArrayInputStream;

public class Demo {

    public static void main(String[] args) throws Exception{
        // Tentukan endpoint wilayah. Dalam contoh ini, endpoint wilayah Tiongkok (Hangzhou) digunakan. 
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Tentukan nama bucket. Contoh: examplebucket. 
        String bucketName = "examplebucket";
        // Tentukan jalur lengkap objek. Contoh: exampledir/exampleobject.txt. Jangan sertakan nama bucket dalam jalur lengkap. 
        String objectName = "exampledir/exampleobject.txt";
        // Tentukan alamat server ke mana permintaan callback dikirim. Contoh: https://example.com:23450. 
        String callbackUrl = "yourCallbackServerUrl";
        // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. 
        String region = "cn-hangzhou";

        // Buat instance OSSClient. 
        // Panggil metode shutdown untuk melepaskan sumber daya terkait saat OSSClient tidak lagi digunakan.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();
        
        try {
            String content = "Hello OSS";
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName,new ByteArrayInputStream(content.getBytes()));

            // Konfigurasikan parameter callback unggah.
            Callback callback = new Callback();
            callback.setCallbackUrl(callbackUrl);
            // (Opsional) Tentukan bidang CallbackHost dalam header permintaan callback. 
            // callback.setCallbackHost("yourCallbackHost");
            
            // Atur badan permintaan callback dalam format JSON dan tentukan variabel placeholder di dalamnya. 
            callback.setCalbackBodyType(Callback.CalbackBodyType.JSON);
            callback.setCallbackBody("{\\\"bucket\\\":${bucket},\\\"object\\\":${object},\\\"mimeType\\\":${mimeType},\\\"size\\\":${size},\\\"my_var1\\\":${x:var1},\\\"my_var2\\\":${x:var2}}");

            // Konfigurasikan parameter kustom untuk permintaan callback. Setiap parameter kustom terdiri dari kunci dan nilai. Kunci harus dimulai dengan x:. 
            callback.addCallbackVar("x:var1", "value1");
            callback.addCallbackVar("x:var2", "value2");
            putObjectRequest.setCallback(callback);

            // Lakukan operasi unggah.
            PutObjectResult putObjectResult = ossClient.putObject(putObjectRequest);

            // Baca konten pesan yang dikembalikan dari callback unggah. 
            byte[] buffer = new byte[1024];
            putObjectResult.getResponse().getContent().read(buffer);
            // Anda harus menutup stream yang diperoleh setelah data dibaca. Jika tidak, kebocoran koneksi mungkin terjadi. Akibatnya, tidak ada koneksi yang tersedia dan pengecualian terjadi. 
            putObjectResult.getResponse().getContent().close();
        } catch (OSSException oe) {
            System.out.println("Tangkap OSSException, yang berarti permintaan Anda sampai ke OSS, "
                    + "tetapi ditolak dengan respons kesalahan karena suatu alasan.");
            System.out.println("Pesan Kesalahan:" + oe.getErrorMessage());
            System.out.println("Kode Kesalahan:" + oe.getErrorCode());
            System.out.println("ID Permintaan:" + oe.getRequestId());
            System.out.println("ID Host:" + oe.getHostId());
        } catch (Throwable ce) {
            System.out.println("Tangkap ClientException, yang berarti klien mengalami "
                    + "masalah internal serius saat mencoba berkomunikasi dengan OSS, "
                    + "seperti tidak dapat mengakses jaringan.");
            System.out.println("Pesan Kesalahan:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}
    import base64
import argparse
import alibabacloud_oss_v2 as oss

parser = argparse.ArgumentParser(description="contoh unggah objek")

# Tambahkan parameter yang diperlukan
parser.add_argument('--region', help='Wilayah tempat bucket berada.', required=True)
parser.add_argument('--bucket', help='Nama bucket.', required=True)
parser.add_argument('--endpoint', help='Nama domain yang dapat digunakan layanan lain untuk mengakses OSS')
parser.add_argument('--key', help='Nama objek.', required=True)
parser.add_argument('--call_back_url', help='Alamat server callback.', required=True)


def main():

    args = parser.parse_args()

    # Dapatkan kredensial akses dari variabel lingkungan
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Konfigurasikan klien SDK
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    # Buat klien OSS
    client = oss.Client(cfg)

    # Konten untuk diunggah (string)
    data = 'hello world'

    # Bangun parameter callback: tentukan alamat callback dan badan permintaan callback, menggunakan pengkodean Base64
    callback=base64.b64encode(str('{\"callbackUrl\":\"' + args.call_back_url + '\",\"callbackBody\":\"bucket=${bucket}&object=${object}&my_var_1=${x:var1}&my_var_2=${x:var2}\"}').encode()).decode(),
    # Bangun variabel kustom (callback-var), menggunakan pengkodean Base64
    callback_var=base64.b64encode('{\"x:var1\":\"value1\",\"x:var2\":\"value2\"}'.encode()).decode(),

    # Mulai permintaan unggah dengan parameter callback
    result = client.put_object(oss.PutObjectRequest(
        bucket=args.bucket,
        key=args.key,
        body=data,
        callback=callback,
        callback_var=callback_var,
    ))
    # Cetak hasil pengembalian (termasuk kode status, ID permintaan, dll.)
    print(vars(result))


if __name__ == "__main__":
    main()
    const OSS = require("ali-oss");

varpath = require("path");

const client = new OSS({
  // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke oss-cn-hangzhou. 
  region: "yourregion",
  // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  authorizationV4: true,
  // Tentukan nama bucket. 
  bucket: "examplebucket",
});

const options = {
  callback: {
    // Tentukan alamat server callback yang menerima permintaan callback. Contoh: http://oss-demo.aliyuncs.com:23450. 
    url: "http://oss-demo.aliyuncs.com:23450",
    // (Opsional) Tentukan bidang Host yang termasuk dalam header permintaan callback. 
    //host: 'yourCallbackHost',
    // Tentukan badan permintaan callback. 
    body: "bucket=${bucket}&object=${object}&var1=${x:var1}&var2=${x:var2}",
    // Tentukan Content-Type dalam permintaan callback. 
    contentType: "application/x-www-form-urlencoded",
    // Menentukan apakah OSS mengirim Server Name Indication (SNI) ke alamat asal yang ditentukan oleh callbackUrl saat permintaan callback diinisiasi dari klien.
    callbackSNI: true,
    // Konfigurasikan parameter kustom untuk permintaan callback. 
    customValue: {
      var1: "value1",
      var2: "value2",
    },
  },
};

async function put() {
  try {
    // Tentukan jalur lengkap objek dan file lokal. Jangan sertakan nama bucket dalam jalur lengkap objek. 
    // Secara default, jika Anda tidak menentukan jalur file lokal, file akan diunggah dari jalur lokal proyek tempat program sampel milik. 
    let result = await client.put(
      "exampleobject.txt",
      path.normalize("/localpath/examplefile.txt"),
      options
    );
    console.log(result);
  } catch (e) {
    console.log(e);
  }
}

put();

    using System;
using System.IO;
using System.Text;
using Aliyun.OSS;
using Aliyun.OSS.Common;
using Aliyun.OSS.Util;
namespace Callback
{
    class Program
    {
        static void Main(string[] args)
        {
            Program.PutObjectCallback();
            Console.ReadKey();
        }
        public static void PutObjectCallback()
        {
            // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
            var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
            var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
            // Tentukan nama bucket. Contoh: examplebucket. 
            var bucketName = "examplebucket";
            // Tentukan jalur lengkap objek. Jangan sertakan nama bucket dalam jalur lengkap. Contoh: exampledir/exampleobject.txt. 
            var objectName = "exampledir/exampleobject.txt";
           // Tentukan jalur lengkap file lokal yang ingin Anda unggah. Contoh: D:\\localpath\\examplefile.txt. Secara default, jika Anda tidak menentukan jalur file lokal, file akan diunggah dari jalur lokal proyek tempat program sampel milik. 
            var localFilename = "D:\\localpath\\examplefile.txt";
            // Tentukan URL server callback. Contoh: https://example.com:23450. 
            const string callbackUrl = "yourCallbackServerUrl";
            // Tentukan bidang callbackBody yang termasuk dalam permintaan callback. 
            const string callbackBody = "bucket=${bucket}&object=${object}&etag=${etag}&size=${size}&mimeType=${mimeType}&" +
                                        "my_var1=${x:var1}&my_var2=${x:var2}";
            // Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com.
            const string endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
            // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou.
            const string region = "cn-hangzhou";
            // Buat instance ClientConfiguration dan modifikasi parameter default berdasarkan kebutuhan Anda.
            var conf = new ClientConfiguration();
            // Gunakan algoritma tanda tangan V4.
            conf.SignatureVersion = SignatureVersion.V4;

            // Buat instance OSSClient.
            var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
            client.SetRegion(region);
            try
            {
                string responseContent = "";
                var metadata = BuildCallbackMetadata(callbackUrl, callbackBody);
                using (var fs = File.Open(localFilename, FileMode.Open))
                {
                    var putObjectRequest = new PutObjectRequest(bucketName, objectName, fs, metadata);
                    var result = client.PutObject(putObjectRequest);
                    responseContent = GetCallbackResponse(result);
                }
                Console.WriteLine("Unggah objek:{0} berhasil, isi respons callback:{1}", objectName, responseContent);
            }
            catch (OssException ex)
            {
                Console.WriteLine("Gagal dengan kode kesalahan: {0}; Info kesalahan: {1}. \nRequestID: {2}\tHostID: {3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Gagal dengan info kesalahan: {0}", ex.Message);
            }
        }
        // Konfigurasikan callback unggah. 
        private static ObjectMetadata BuildCallbackMetadata(string callbackUrl, string callbackBody)
        {
            string callbackHeaderBuilder = new CallbackHeaderBuilder(callbackUrl, callbackBody).Build();
            string CallbackVariableHeaderBuilder = new CallbackVariableHeaderBuilder().
                AddCallbackVariable("x:var1", "x:value1").AddCallbackVariable("x:var2", "x:value2").Build();
            var metadata = new ObjectMetadata();
            metadata.AddHeader(HttpHeaders.Callback, callbackHeaderBuilder);
            metadata.AddHeader(HttpHeaders.CallbackVar, CallbackVariableHeaderBuilder);
            return metadata;
        }
        // Baca respons permintaan callback unggah. 
        private static string GetCallbackResponse(PutObjectResult putObjectResult)
        {
            string callbackResponse = null;
            using (var stream = putObjectResult.ResponseStream)
            {
                var buffer = new byte[4 * 1024];
                var bytesRead = stream.Read(buffer, 0, buffer.Length);
                callbackResponse = Encoding.Default.GetString(buffer, 0, bytesRead);
            }
            return callbackResponse;
        }
    }
}
    // Bangun permintaan unggah. 
// Tentukan nama bucket, jalur lengkap objek, dan jalur lengkap file lokal. Dalam contoh ini, nama bucket adalah examplebucket, jalur lengkap objek adalah exampledir/exampleobject.txt, dan jalur lengkap file lokal adalah /storage/emulated/0/oss/examplefile.txt. 
// Jangan sertakan nama bucket dalam jalur lengkap objek. 
PutObjectRequest put = new PutObjectRequest("examplebucket", "exampledir/exampleobject.txt", "/storage/emulated/0/oss/examplefile.txt");

put.setCallbackParam(new HashMap<String, String>() {
    {
        put("callbackUrl", "http://oss-demo.aliyuncs.com:23450");
        put("callbackHost", "yourCallbackHost");
        put("callbackBodyType", "application/json");
        put("callbackBody", "{\"mimeType\":${mimeType},\"size\":${size}}");
    }
});

OSSAsyncTask task = oss.asyncPutObject(put, new OSSCompletedCallback<PutObjectRequest, PutObjectResult>() {
    @Override
    public void onSuccess(PutObjectRequest request, PutObjectResult result) {
        Log.d("PutObject", "Unggah Berhasil");

        // Dapatkan informasi callback yang dikembalikan. Anda hanya bisa mendapatkan informasi callback jika Anda menentukan servercallback dalam permintaan. 
        String serverCallbackReturnJson = result.getServerCallbackReturnBody();

        Log.d("servercallback", serverCallbackReturnJson);
    }

    @Override
    public void onFailure(PutObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // Tangani pengecualian. 
    }
});
        
    OSSPutObjectRequest * request = [OSSPutObjectRequest new];
// Tentukan nama bucket. Contoh: examplebucket. 
request.bucketName = @"examplebucket";
// Tentukan jalur lengkap objek. Jangan sertakan nama bucket dalam jalur lengkap. Contoh: exampledir/exampleobject.txt. 
request.objectKey = @"exampledir/exampleobject.txt";
request.uploadingFileURL = [NSURL fileURLWithPath:@"<filepath>"];
// Konfigurasikan parameter callback.
request.callbackParam = @{
                          @"callbackUrl": @"<alamat server callback Anda>",
                          @"callbackBody": @"<badan callback Anda>"
                          };
// Tentukan variabel kustom. 
request.callbackVar = @{
                        @"<var1>": @"<value1>",
                        @"<var2>": @"<value2>"
                        };
request.uploadProgress = ^(int64_t bytesSent, int64_t totalByteSent, int64_t totalBytesExpectedToSend) {
    NSLog(@"%lld, %lld, %lld", bytesSent, totalByteSent, totalBytesExpectedToSend);
};
OSSTask * task = [client putObject:request];
[task continueWithBlock:^id(OSSTask *task) {
    if (task.error) {
        OSSLogError(@"%@", task.error);
    } else {
        OSSPutObjectResult * result = task.result;
        NSLog(@"Hasil - requestId: %@, headerFields: %@, servercallback: %@",
              result.requestId,
              result.httpResponseHeaderFields,
              result.serverReturnJsonString);
    }
    return nil;
}];
// Implementasikan pemblokiran sinkron untuk menunggu tugas selesai. 
// [task waitUntilFinished]; 
    #include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* Inisialisasi informasi akun yang digunakan untuk mengakses OSS. */
            
    /* Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. */
    std::string Region = "yourRegion";
    /* Tentukan nama bucket. Contoh: examplebucket. */
    std::string BucketName = "examplebucket";
    /* Tentukan jalur lengkap objek. Jangan sertakan nama bucket dalam jalur lengkap objek. Contoh: exampledir/exampleobject.txt. */
    std::string ObjectName = "exampledir/exampleobject.txt";
    /* Tentukan URL server callback. */
    std::string ServerName = "https://example.aliyundoc.com:23450";

     /* Inisialisasi sumber daya seperti sumber daya jaringan. */
    InitializeSdk();

    ClientConfiguration conf;
    conf.signatureVersion = SignatureVersionType::V4;
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. */
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);
    client.SetRegion(Region);
    std::shared_ptr<std::iostream> content = std::make_shared<std::stringstream>();
    *content << "Terima kasih telah menggunakan Layanan Penyimpanan Objek Aliyun!";

    /* Konfigurasikan parameter callback unggah. */
    std::string callbackBody = "bucket=${bucket}&object=${object}&etag=${etag}&size=${size}&mimeType=${mimeType}&my_var1=${x:var1}";
    ObjectCallbackBuilder builder(ServerName, callbackBody, "", ObjectCallbackBuilder::Type::URL);
    std::string value = builder.build();
    ObjectCallbackVariableBuilder varBuilder;
    varBuilder.addCallbackVariable("x:var1", "value1");
    std::string varValue = varBuilder.build();
    PutObjectRequest request(BucketName, ObjectName, content);
    request.MetaData().addHeader("x-oss-callback", value);
    request.MetaData().addHeader("x-oss-callback-var", varValue);
    auto outcome = client.PutObject(request);

    /* Lepaskan sumber daya seperti sumber daya jaringan. */
    ShutdownSdk();
    return 0;
}
    #include "oss_api.h"
#include "aos_http_io.h"
/* Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. */
const char *endpoint = "yourEndpoint";

/* Tentukan nama bucket. Contoh: examplebucket. */
const char *bucket_name = "examplebucket";
/* Tentukan jalur lengkap objek. Jangan sertakan nama bucket dalam jalur lengkap. Contoh: exampledir/exampleobject.txt. */
const char *object_name = "exampledir/exampleobject.txt";
const char *object_content = "More than just cloud.";
/* Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. */
const char *region = "yourRegion";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* Gunakan string char* untuk menginisialisasi data bertipe aos_string_t. */
    aos_str_set(&options->config->endpoint, endpoint);
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. */    
    aos_str_set(&options->config->access_key_id, getenv("OSS_ACCESS_KEY_ID"));
    aos_str_set(&options->config->access_key_secret, getenv("OSS_ACCESS_KEY_SECRET"));
    // Tentukan dua parameter tambahan.
    aos_str_set(&options->config->region, region);
    options->config->signature_version = 4;
    /* Tentukan apakah menggunakan CNAME. Nilai 0 menunjukkan bahwa CNAME tidak digunakan. */
    options->config->is_cname = 0;
    /* Konfigurasikan parameter jaringan, seperti periode timeout. */
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    aos_pool_t *p = NULL;
    aos_status_t *s = NULL;
    aos_string_t bucket;
    aos_string_t object;
    aos_table_t *headers = NULL;
    oss_request_options_t *options = NULL;
    aos_table_t *resp_headers = NULL;
    aos_list_t resp_body;
    aos_list_t buffer;
    aos_buf_t *content;
    char *buf = NULL;
    int64_t len = 0;
    int64_t size = 0;
    int64_t pos = 0;
    char b64_buf[1024];
    int b64_len;
    /* Tentukan parameter callback dalam format JSON. */
    /* (Opsional) Tentukan bidang Host yang termasuk dalam header permintaan callback. */
    char *callback =  "{"
        "\"callbackUrl\":\"http://oss-demo.aliyuncs.com:23450\","
         "\"callbackHost\":\"yourCallbackHost\","
        "\"callbackBody\":\"bucket=${bucket}&object=${object}&size=${size}&mimeType=${mimeType}\","
        "\"callbackBodyType\":\"application/x-www-form-urlencoded\""
        "}";
    /* Panggil metode aos_http_io_initialize di main() untuk menginisialisasi sumber daya global, seperti sumber daya jaringan dan memori. */
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* Inisialisasi parameter. */
    aos_pool_create(&p, NULL);
    options = oss_request_options_create(p);
    init_options(options);
    aos_str_set(&bucket, bucket_name);
    aos_str_set(&object, object_name);
    aos_list_init(&resp_body);
    aos_list_init(&buffer);
    content = aos_buf_pack(options->pool, object_content, strlen(object_content));
    aos_list_add_tail(&content->node, &buffer);
    /* Tambahkan callback ke header. */
    b64_len = aos_base64_encode((unsigned char*)callback, strlen(callback), b64_buf);
    b64_buf[b64_len] = '\0';
    headers = aos_table_make(p, 1);
    apr_table_set(headers, OSS_CALLBACK, b64_buf);
    /* Konfigurasikan callback unggah. */
    s = oss_do_put_object_from_buffer(options, &bucket, &object, &buffer,
        headers, NULL, NULL, &resp_headers, &resp_body);
    if (aos_status_is_ok(s)) {
        printf("put object from buffer succeeded\n");
    } else {
        printf("put object from buffer failed\n");
    }
    /* Dapatkan panjang buffer. */
    len = aos_buf_list_len(&resp_body);
    buf = (char *)aos_pcalloc(p, (apr_size_t)(len + 1));
    buf[len] = '\0';
    /* Salin konten dalam buffer ke memori. */
    aos_list_for_each_entry(aos_buf_t, content, &resp_body, node) {
        size = aos_buf_size(content);
        memcpy(buf + pos, content->pos, (size_t)size);
        pos += size;
    }
    /* Lepaskan kolam memori. Operasi ini melepaskan sumber daya memori yang dialokasikan untuk permintaan. */
    aos_pool_destroy(p);
    /* Lepaskan sumber daya global yang dialokasikan. */
    aos_http_io_deinitialize();
    return 0;
}
    require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # Dalam contoh ini, endpoint wilayah Tiongkok (Hangzhou) digunakan. Tentukan endpoint aktual Anda. 
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
    # Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode sampel, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
  access_key_id: ENV['OSS_ACCESS_KEY_ID'],
  access_key_secret: ENV['OSS_ACCESS_KEY_SECRET']
)
# Tentukan nama bucket. Contoh: examplebucket. 
bucket = client.get_bucket('examplebucket')

callback = Aliyun::OSS::Callback.new(
  url: 'http://oss-demo.aliyuncs.com:23450',
  query: {user: 'put_object'},
  body: 'bucket=${bucket}&object=${object}'
)

begin
  bucket.put_object('files/hello', file: '/tmp/x', callback: callback)
rescue Aliyun::OSS::CallbackError => e
  puts "Callback gagal: #{e.message}"
end
    package main

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"flag"
	"log"
	"strings"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

// Tentukan variabel global.
var (
	region     string // Wilayah tempat bucket berada.
	bucketName string // Nama bucket.
	objectName string // Nama objek.
)

// Tentukan fungsi init yang digunakan untuk menginisialisasi parameter baris perintah.
func init() {
	flag.StringVar(&region, "region", "", "Wilayah tempat bucket berada.")
	flag.StringVar(&bucketName, "bucket", "", "Nama bucket.")
	flag.StringVar(&objectName, "object", "", "Nama objek.")
}

func main() {
	// Parsing parameter baris perintah.
	flag.Parse()

	// Periksa apakah nama bucket kosong.
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, nama bucket diperlukan")
	}

	// Periksa apakah wilayah kosong.
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, wilayah diperlukan")
	}

	// Periksa apakah nama objek kosong.
	if len(objectName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, nama objek diperlukan")
	}

	// Muat konfigurasi default dan tentukan penyedia kredensial dan wilayah.
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// Buat instance OSSClient.
	client := oss.NewClient(cfg)

	// Tentukan parameter callback.
	callbackMap := map[string]string{
		"callbackUrl":      "http://example.com:23450",                                                        // Tentukan URL server callback. Contoh: https://example.com:23450.
		"callbackBody":     "bucket=${bucket}&object=${object}&size=${size}&my_var_1=${x:my_var1}&my_var_2=${x:my_var2}", // Tentukan badan permintaan callback.
		"callbackBodyType": "application/x-www-form-urlencoded",                                                          // Tentukan tipe badan permintaan callback.
	}

	// Konversi konfigurasi parameter callback ke string JSON dan enkode string tersebut dalam Base64 untuk melewati konfigurasi callback.
	callbackStr, err := json.Marshal(callbackMap)
	if err != nil {
		log.Fatalf("gagal mengonversi peta callback: %v", err)
	}
	callbackBase64 := base64.StdEncoding.EncodeToString(callbackStr)

	callbackVarMap := map[string]string{}
	callbackVarMap["x:my_var1"] = "ini adalah var 1"
	callbackVarMap["x:my_var2"] = "ini adalah var 2"
	callbackVarStr, err := json.Marshal(callbackVarMap)
	if err != nil {
		log.Fatalf("gagal mengonversi variabel callback: %v", err)
	}
	callbackVarBase64 := base64.StdEncoding.EncodeToString(callbackVarStr)
	// Tentukan string yang ingin diunggah.
	body := strings.NewReader("Halo, OSS!") // String yang ingin diunggah.

	// Buat permintaan untuk mengunggah file lokal.
	request := &oss.PutObjectRequest{
		Bucket:      oss.Ptr(bucketName),        // Nama bucket.
		Key:         oss.Ptr(objectName),        // Nama objek.
		Body:        body,                       // Konten objek.
		Callback:    oss.Ptr(callbackBase64),    // Parameter callback.
		CallbackVar: oss.Ptr(callbackVarBase64),
	}

	// Eksekusi permintaan untuk mengunggah file lokal.
	result, err := client.PutObject(context.TODO(), request)
	if err != nil {
		log.Fatalf("gagal mengunggah objek %v", err)
	}

	// Tampilkan hasil operasi unggah objek.
	log.Printf("hasil unggah objek:%#v\n", result)
}

    <?php

// Masukkan file autoload untuk memuat library dependensi.
require_once __DIR__ . '/../vendor/autoload.php';

use AlibabaCloud\Oss\V2 as Oss;

// Tentukan deskripsi untuk parameter baris perintah.
$optsdesc = [
    "region" => ['help' => 'Wilayah tempat bucket berada.', 'required' => True], // (Wajib) Tentukan wilayah tempat bucket berada.
    "endpoint" => ['help' => 'Nama domain yang dapat digunakan layanan lain untuk mengakses OSS.', 'required' => False], // (Opsional) Tentukan endpoint yang dapat digunakan oleh layanan lain untuk mengakses OSS.
    "bucket" => ['help' => 'Nama bucket', 'required' => True], // (Wajib) Tentukan nama bucket.
    "key" => ['help' => 'Nama objek', 'required' => True], // (Wajib) Tentukan nama objek.
];

// Konversi deskripsi parameter menjadi daftar opsi panjang yang diperlukan oleh getopt.
// Tambahkan titik dua (:) di akhir setiap parameter untuk menunjukkan bahwa nilai diperlukan.
$longopts = \array_map(function ($key) {
    return "$key:";
}, array_keys($optsdesc));

// Parsing parameter baris perintah.
$options = getopt("", $longopts);

// Periksa apakah parameter wajib telah dikonfigurasi.
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help']; // Dapatkan informasi bantuan tentang parameter.
        echo "Error: argumen berikut diperlukan: --$key, $help" . PHP_EOL;
        exit(1); // Jika parameter wajib tidak dikonfigurasi, keluar dari program.
    }
}

// Dapatkan nilai dari parameter yang telah diparsing.
$region = $options["region"]; // Wilayah tempat bucket berada.
$bucket = $options["bucket"]; // Nama bucket.
$key = $options["key"]; // Nama objek.

// Dapatkan kredensial akses dari variabel lingkungan.
// Dapatkan AccessKey ID dan AccessKey secret dari penyedia EnvironmentVariableCredentialsProvider.
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();

// Gunakan konfigurasi default SDK.
$cfg = Oss\Config::loadDefault();
$cfg->setCredentialsProvider($credentialsProvider); // Tentukan penyedia kredensial.
$cfg->setRegion($region); // Tentukan wilayah tempat bucket berada.
if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]); // Tentukan endpoint jika endpoint disediakan.
}

// Buat instance OSSClient.
$client = new Oss\Client($cfg);

// Tentukan informasi server callback.
// Tentukan URL callback, yaitu alamat server yang menerima permintaan callback.
// Tentukan host callback, yaitu nama host server callback.
// Tentukan badan callback, yaitu template yang digunakan untuk menentukan konten callback. Placeholder dinamis didukung.
// Tentukan tipe badan callback, yaitu format konten callback.
$callback = base64_encode(json_encode(array(
    'callbackUrl' => yourCallbackServerUrl, // Ganti yourCallbackServerUrl dengan URL server callback aktual.
    'callbackHost' => 'CallbackHost', // Ganti CallbackHost dengan nama host server callback aktual.
    'callbackBody' => 'bucket=${bucket}&object=${object}&etag=${etag}&size=${size}&mimeType=${mimeType}&imageInfo.height=${imageInfo.height}&imageInfo.width=${imageInfo.width}&imageInfo.format=${imageInfo.format}&my_var1=${x:var1}&my_var2=${x:var2}',
    'callbackBodyType' => "application/x-www-form-urlencoded", // Tentukan format konten callback.
)));

// Tentukan variabel kustom untuk menyampaikan informasi tambahan dalam callback.
$callbackVar = base64_encode(json_encode(array(
    'x:var1' => "value1", // Tentukan variabel kustom pertama.
    'x:var2' => 'value2', // Tentukan variabel kustom kedua.
)));

// Buat objek PutObjectRequest untuk mengunggah file lokal.
$request = new Oss\Models\PutObjectRequest(bucket: $bucket, key: $key);
$request->callback = $callback; // Tentukan informasi callback.
$request->callbackVar = $callbackVar; // Tentukan variabel kustom.

// Eksekusi permintaan unggah sederhana.
$result = $client->putObject($request);

// Tampilkan hasil permintaan unggah sederhana.
// Tampilkan kode status HTTP, ID permintaan, dan hasil callback untuk memeriksa apakah permintaan berhasil.
printf(
    'kode status:' . $result->statusCode . PHP_EOL . // Kode status HTTP. Misalnya, kode status HTTP 200 menunjukkan bahwa permintaan berhasil.
    'ID permintaan:' . $result-> requestId. PHP_EOL // ID permintaan, yang digunakan untuk debugging atau melacak permintaan.
    'hasil callback:' . var_export($result->callbackResult, true) . PHP_EOL // Detail hasil callback.
);

    Operasi API terkait

    Metode yang dijelaskan di atas pada dasarnya diimplementasikan berdasarkan API RESTful, yang dapat Anda panggil langsung jika bisnis Anda memerlukan tingkat penyesuaian yang tinggi. Untuk memanggil API secara langsung, Anda harus menyertakan perhitungan tanda tangan dalam kode Anda. Untuk informasi lebih lanjut, lihat Callback.

    Referensi