Object Storage Service：Membuat bucket penyimpanan redundan zona

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. 
        String endpoint = "yourEndpoint";
        // 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. 
        String bucketName = "examplebucket";
        // Tentukan ID grup sumber daya. Jika Anda tidak menentukan ID grup sumber daya, bucket termasuk dalam grup sumber daya default. 
        //String rsId = "rg-aek27tc****";
        // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (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 {
            // Buat bucket dan aktifkan fitur namespace bertingkat untuk bucket. 
            CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName).withHnsStatus(HnsStatus.Enabled);
            // Kode berikut memberikan contoh cara menentukan kelas penyimpanan, daftar kontrol akses (ACL), dan tipe redundansi saat Anda membuat bucket. 
            // Dalam contoh ini, kelas penyimpanan bucket adalah Standard. 
            createBucketRequest.setStorageClass(StorageClass.Standard);
            // Tipe redundansi default bucket adalah DataRedundancyType.LRS. 
            createBucketRequest.setDataRedundancyType(DataRedundancyType.LRS);
            // Setel ACL bucket ke publik-baca. Defaultnya adalah pribadi. 
            createBucketRequest.setCannedACL(CannedAccessControlList.PublicRead);
            // Saat Anda membuat bucket di wilayah yang mendukung grup sumber daya, Anda dapat mengonfigurasi grup sumber daya untuk bucket. 
            //createBucketRequest.setResourceGroupId(rsId);

            ossClient.createBucket(createBucketRequest);

            // Buat bucket. 
            ossClient.createBucket(createBucketRequest);
        } catch (OSSException oe) {
            System.out.println("Tangkap OSSException, yang berarti permintaan Anda mencapai OSS, "
                    + "tetapi ditolak dengan respons kesalahan karena alasan tertentu.");
            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 (ClientException 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();
            }
        }
    }
}

<?php

// Secara otomatis memuat objek dan pustaka dependensi.
require_once __DIR__ . '/../vendor/autoload.php'; 

use AlibabaCloud\Oss\V2 as Oss;

// Tentukan parameter baris perintah.
$optsdesc = [
    "region" => ['help' => 'Wilayah tempat bucket berada.', 'required' => True], // Parameter wilayah diperlukan. Contoh: oss-cn-hangzhou.
    "endpoint" => ['help' => 'Nama domain yang dapat digunakan layanan lain untuk mengakses OSS.', 'required' => False], // Parameter endpoint opsional.
    "bucket" => ['help' => 'Nama bucket', 'required' => True], // Nama bucket diperlukan.
];

// Hasilkan daftar opsi panjang untuk mem-parsing parameter baris perintah.
$longopts = \array_map(function ($key) {
    return "$key:"; // Titik dua (:) setelah setiap parameter menunjukkan bahwa parameter tersebut diperlukan.
}, array_keys($optsdesc));

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

// Periksa apakah parameter yang diperlukan telah dikonfigurasi.
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help'];
        echo "Error: argumen berikut diperlukan: --$key, $help"; // Menentukan bahwa parameter yang diperlukan belum dikonfigurasi.
        exit(1); 
    }
}

// Ambil nilai parameter baris perintah.
$region = $options["region"]; // Wilayah tempat bucket berada.
$bucket = $options["bucket"]; // Nama bucket.

// Muat informasi kredensial (AccessKeyId dan AccessKeySecret) dari variabel lingkungan.
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider(); 

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

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

// Buat permintaan untuk memulai pembuatan bucket.
$request = new Oss\Models\PutBucketRequest($bucket); 

// Panggil metode putBucket.
$result = $client->putBucket($request);

// Keluarkan hasilnya.
printf(
    'kode status:' . $result->statusCode . PHP_EOL . // Kode status HTTP.
    'ID permintaan:' . $result->requestId // ID unik permintaan.
);

const OSS = require('ali-oss');

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

// Buat bucket. 
async function putBucket() {
  try {
    const options = {
      storageClass: 'Standard', // Secara default, kelas penyimpanan bucket adalah Standard. Untuk menetapkan kelas penyimpanan bucket ke Arsip, atur storageClass ke Arsip. 
      acl: 'private', // Secara default, daftar kontrol akses (ACL) bucket adalah pribadi. Untuk menetapkan ACL bucket ke publik-baca, atur acl ke publik-baca. 
      dataRedundancyType: 'LRS' // Secara default, tipe redundansi bucket adalah penyimpanan redundan lokal (LRS). Untuk menetapkan tipe redundansi bucket ke penyimpanan redundan zona (ZRS), atur dataRedundancyType ke ZRS. 
    }
    // Tentukan nama bucket. 
    const result = await client.putBucket('examplebucket', options);
    console.log(result);
  } catch (err) {
    console.log(err);
  }
}

putBucket();        

import argparse
import alibabacloud_oss_v2 as oss

# Buat parser argumen baris perintah.
parser = argparse.ArgumentParser(description="contoh put bucket")
# Tentukan parameter baris perintah --region yang diperlukan, yang menentukan wilayah tempat bucket berada.
parser.add_argument('--region', help='Wilayah tempat bucket berada.', required=True)
# Tentukan parameter baris perintah --bucket yang diperlukan, yang menentukan nama bucket. 
parser.add_argument('--bucket', help='Nama bucket.', required=True)
# Tentukan parameter baris perintah --endpoint opsional, yang menentukan endpoint yang dapat digunakan layanan lain untuk mengakses OSS.
parser.add_argument('--endpoint', help='Nama domain yang dapat digunakan layanan lain untuk mengakses OSS')

def main():
    args = parser.parse_args()  # Parsing parameter baris perintah.

    # Muat kredensial akses dari variabel lingkungan untuk autentikasi.
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Muat konfigurasi default SDK dan tentukan penyedia kredensial.
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    # Tentukan wilayah tempat bucket berada.
    cfg.region = args.region
    # Jika parameter endpoint disediakan, tentukan endpoint yang dapat digunakan layanan lain untuk mengakses OSS.
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    # Gunakan konfigurasi untuk membuat instance OSSClient.
    client = oss.Client(cfg)

    # Eksekusi permintaan untuk membuat bucket dan atur kelas penyimpanannya ke Standard.
    result = client.put_bucket(oss.PutBucketRequest(
        bucket=args.bucket,
        create_bucket_configuration=oss.CreateBucketConfiguration(
            storage_class='Standard'
        )
    ))
    # Keluarkan kode status HTTP dalam respons dan ID permintaan yang digunakan untuk memeriksa apakah permintaan berhasil.
    print(f'kode status: {result.status_code},'
          f' ID permintaan: {result.request_id},'
    )


if __name__ == "__main__":
    main()  # Titik masuk skrip. Fungsi utama dipanggil saat file dijalankan langsung.

using Aliyun.OSS;
using Aliyun.OSS.Common;

// Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. 
var endpoint = "yourEndpoint";
// 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. 
var bucketName = "examplebucket";
// Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (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);
// Buat bucket. 
try
    {
        var request = new CreateBucketRequest(bucketName);
        // Atur daftar kontrol akses (ACL) bucket ke PublicRead. Nilai defaultnya adalah pribadi. 
        request.ACL = CannedAccessControlList.PublicRead;
        // Atur tipe redundansi bucket ke penyimpanan redundan zona (ZRS). 
        request.DataRedundancyType = DataRedundancyType.ZRS;
        client.CreateBucket(request);
        Console.WriteLine("Pembuatan bucket berhasil");
    }
    catch (Exception ex)
    {
        Console.WriteLine("Pembuatan bucket gagal. {0}", ex.Message);
    }

// Konstruksi permintaan untuk membuat bucket. 
// Tentukan nama bucket. 
CreateBucketRequest createBucketRequest=new CreateBucketRequest("examplebucket");. 
// Tentukan daftar kontrol akses (ACL) bucket. 
// createBucketRequest.setBucketACL(CannedAccessControlList.Private);
// Tentukan kelas penyimpanan bucket. 
// createBucketRequest.setBucketStorageClass(StorageClass.Standard);

// Buat bucket secara asinkron. 
OSSAsyncTask createTask = oss.asyncCreateBucket(createBucketRequest, new OSSCompletedCallback<CreateBucketRequest, CreateBucketResult>() {
    @Override
    public void onSuccess(CreateBucketRequest request, CreateBucketResult result) {
        Log.d("asyncCreateBucket", "Berhasil");
    }
    @Override
    public void onFailure(CreateBucketRequest request, ClientException clientException, ServiceException serviceException) {
        // Tangani pengecualian permintaan. 
        if (clientException != null) {
            // Tangani pengecualian klien, seperti pengecualian jaringan. 
            clientException.printStackTrace();
        }
        if (serviceException != null) {
            // Tangani pengecualian layanan. 
            Log.e("KodeKesalahan", serviceException.getErrorCode());
            Log.e("IDPermintaan", serviceException.getRequestId());
            Log.e("IDHost", serviceException.getHostId());
            Log.e("PesanMentah", serviceException.getRawMessage());
        }
    }
});

// Konstruksi permintaan untuk membuat bucket. 
OSSCreateBucketRequest * create = [OSSCreateBucketRequest new];
// Atur nama bucket ke examplebucket. 
create.bucketName = @"examplebucket";
// Atur daftar kontrol akses (ACL) bucket ke pribadi. 
create.xOssACL = @"private";
// Atur kelas penyimpanan bucket ke Infrequent Access (IA). 
create.storageClass = OSSBucketStorageClassIA;

OSSTask * createTask = [client createBucket:create];

[createTask continueWithBlock:^id(OSSTask *task) {
    if (!task.error) {
        NSLog(@"pembuatan bucket berhasil!");
    } else {
        NSLog(@"pembuatan bucket gagal, error: %@", task.error);
    }
    return nil;
}];
// Implementasikan blokir sinkron untuk menunggu tugas selesai. 
// [createTask 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 China (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 China (Hangzhou), atur wilayah ke cn-hangzhou. */
    std::string Region = "yourRegion";
    
    /* Tentukan nama bucket. Contoh: examplebucket. */
    std::string BucketName = "examplebucket";

    /* 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);

    /* Tentukan nama, kelas penyimpanan, dan daftar kontrol akses (ACL) bucket. */
    CreateBucketRequest request(BucketName, StorageClass::IA, CannedAccessControlList::PublicReadWrite);
    /* Atur tipe redundansi data bucket ke penyimpanan redundan zona (ZRS). */
    //request.setDataRedundancyType(DataRedundancyType::ZRS);

    /* Buat bucket. */
    auto outcome = client.CreateBucket(request);

    if (!outcome.isSuccess()) {
        /* Tangani pengecualian. */
        std::cout << "CreateBucket gagal" <<
        ",kode:" << outcome.error().Code() <<
        ",pesan:" << outcome.error().Message() <<
        ",IDPermintaan:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* 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 China (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 wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (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 untuk mengakses OSS. 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[])
{
    /* 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);
    }
    /* Buat pool memori untuk mengelola memori. aos_pool_t setara dengan apr_pool_t. Kode untuk membuat pool memori disertakan dalam pustaka APR. */
    aos_pool_t *pool;
    /* Buat pool memori. Nilai parameter kedua adalah NULL. Nilai ini menentukan bahwa pool tidak mewarisi pool memori lainnya. */
    aos_pool_create(&pool, NULL);
    /* Buat dan inisialisasi opsi. Parameter ini mencakup informasi konfigurasi global, seperti endpoint, access_key_id, access_key_secret, is_cname, dan curl. */
    oss_request_options_t *oss_client_options;
    /* Alokasikan sumber daya memori di pool memori untuk opsi. */
    oss_client_options = oss_request_options_create(pool);
    /* Inisialisasi oss_client_options. */
    init_options(oss_client_options);
    /* Inisialisasi parameter. */
    aos_string_t bucket;
    oss_acl_e oss_acl = OSS_ACL_PRIVATE;
    aos_table_t *resp_headers = NULL; 
    aos_status_t *resp_status = NULL; 
    /* Tetapkan data char* ke bucket bertipe aos_string_t.  */
    aos_str_set(&bucket, bucket_name);
    /* Buat bucket. */
    resp_status = oss_create_bucket(oss_client_options, &bucket, oss_acl, &resp_headers);
    /* Tentukan apakah bucket berhasil dibuat.  */
    if (aos_status_is_ok(resp_status)) {
        printf("pembuatan bucket berhasil\n");
    } else {
        printf("pembuatan bucket gagal\n");
    }
    /* Lepaskan pool memori. Operasi ini melepaskan sumber daya memori yang dialokasikan untuk permintaan. */
    aos_pool_destroy(pool);
    /* 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 China (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. 
client.create_bucket('examplebucket')

package main

import (
	"context"
	"flag"
	"log"

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

// Definisikan variabel global.
var (
	region     string // Wilayah tempat bucket berada.
	bucketName string // Nama bucket.
)

// 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.")
}

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

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

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

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

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

	// Tentukan parameter dalam permintaan pembuatan bucket.
	request := &oss.PutBucketRequest{
		Bucket: oss.Ptr(bucketName), // Tentukan nama bucket.
		CreateBucketConfiguration: &oss.CreateBucketConfiguration{
			DataRedundancyType: oss.DataRedundancyZRS, // Atur tipe redundansi data ke ZRS.
		},
	}

	// Kirim permintaan.
	result, err := client.PutBucket(context.TODO(), request)
	if err != nil {
		log.Fatalf("gagal menempatkan bucket: %v", err) // Tangani kesalahan dan hentikan program.
	}

	// Tampilkan hasilnya.
	log.Printf("hasil bucket: %#v\n", result)
}