Object Storage Service:Buat bucket

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 {
        // Tetapkan yourEndpoint ke Endpoint region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur Endpoint ke https://oss-cn-hangzhou.aliyuncs.com.
        String endpoint = "yourEndpoint";
        // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh ini, 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 kelompok sumber daya. Jika tidak menentukan ID kelompok sumber daya, bucket akan ditambahkan ke kelompok sumber daya default.
        //String rsId = "rg-aek27tc****";
        // Tentukan region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur Region ke cn-hangzhou.
        String region = "cn-hangzhou";
        
        // Buat instance OSSClient.
        // Setelah instance OSSClient tidak digunakan lagi, panggil metode shutdown untuk melepaskan sumber daya.
        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 hierarkis.
            CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName).withHnsStatus(HnsStatus.Enabled);
            // Jika ingin menentukan kelas penyimpanan, ACL, dan tipe redundansi data saat membuat bucket, lihat kode berikut.
            // Kode berikut memberikan contoh cara mengatur kelas penyimpanan ke Standard.
            createBucketRequest.setStorageClass(StorageClass.Standard);
            // Tipe redundansi data default adalah LRS, yang ditentukan sebagai DataRedundancyType.LRS. Jika ingin mengatur tipe redundansi data ke ZRS, atur nilainya ke DataRedundancyType.ZRS.
            createBucketRequest.setDataRedundancyType(DataRedundancyType.ZRS);
            // Atur ACL bucket ke public-read. ACL default adalah private.
            createBucketRequest.setCannedACL(CannedAccessControlList.PublicRead);
            // Saat membuat bucket di region yang mendukung kelompok sumber daya, Anda dapat menetapkan bucket ke kelompok sumber daya.
            //createBucketRequest.setResourceGroupId(rsId);


            // Buat bucket.
            ossClient.createBucket(createBucketRequest);
        } catch (OSSException oe) {
            System.out.println("Terjadi OSSException, yang berarti permintaan Anda sampai ke OSS, "
                    + "tetapi ditolak dengan tanggapan error karena suatu alasan.");
            System.out.println("Pesan Error:" + oe.getErrorMessage());
            System.out.println("Kode Error:" + oe.getErrorCode());
            System.out.println("ID Permintaan:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Terjadi ClientException, yang berarti klien mengalami "
                    + "masalah internal serius saat mencoba berkomunikasi dengan OSS, "
                    + "seperti tidak dapat mengakses jaringan.");
            System.out.println("Pesan Error:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss

# Buat parser argumen baris perintah.
parser = argparse.ArgumentParser(description="contoh put bucket")
# Tentukan parameter baris perintah wajib --region, yang menentukan region tempat bucket berada.
parser.add_argument('--region', help='Region tempat bucket berada.', required=True)
# Tentukan parameter baris perintah wajib --bucket, yang menentukan nama bucket. 
parser.add_argument('--bucket', help='Nama bucket.', required=True)
# Tentukan parameter baris perintah opsional --endpoint, 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()  # Uraikan 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 region 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)

    # Jalankan 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 tanggapan 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 main dipanggil saat file dijalankan secara langsung.

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"
)

// Tentukan variabel global.
var (
	region     string // Region.
	bucketName string // Nama bucket.
)

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

func main() {
	// Uraikan 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 region kosong.
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, region diperlukan")
	}

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

	// Buat klien OSS.
	client := oss.NewClient(cfg)

	request := &oss.PutBucketRequest{
		Bucket: oss.Ptr(bucketName), // Nama bucket.
	}

	// Kirim permintaan untuk membuat bucket.
	result, err := client.PutBucket(context.TODO(), request)
	if err != nil {
		log.Fatalf("gagal membuat bucket %v", err)
	}

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

<?php

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

use AlibabaCloud\Oss\V2 as Oss;

// Tentukan parameter baris perintah.
$optsdesc = [
    "region" => ['help' => 'Region tempat bucket berada.', 'required' => True], // Parameter region wajib. 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 wajib.
];

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

// Uraikan 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'];
        echo "Error: argumen berikut wajib: --$key, $help"; // Menentukan bahwa parameter wajib belum dikonfigurasi.
        exit(1); 
    }
}

// Ambil nilai parameter baris perintah.
$region = $options["region"]; // Region 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 region.
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.
);

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

// Tetapkan yourEndpoint ke Endpoint region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur Endpoint ke https://oss-cn-hangzhou.aliyuncs.com.
var endpoint = "yourEndpoint";
// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, 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 region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur region ke cn-hangzhou.
const string region = "cn-hangzhou";

// Buat instance ClientConfiguration dan ubah parameter default sesuai kebutuhan.
var conf = new ClientConfiguration();

// Gunakan Signature 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) ke public-read. ACL default adalah private.
        request.ACL = CannedAccessControlList.PublicRead;
        // Atur tipe pemulihan bencana data ke penyimpanan redundan zona.
        request.DataRedundancyType = DataRedundancyType.ZRS;
        client.CreateBucket(request);
        Console.WriteLine("Berhasil membuat bucket");
    }
    catch (Exception ex)
    {
        Console.WriteLine("Gagal membuat bucket. {0}", ex.Message);
    }

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

const client = new OSS({
  // Tentukan region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur region ke oss-cn-hangzhou. 
  region: 'yourregion',
  // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, 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: 'yourBucketName',
});

// Buat bucket. 
async function putBucket() {
  try {
    const options = {
      storageClass: 'Standard', // Secara default, kelas penyimpanan bucket adalah Standard. Untuk mengatur kelas penyimpanan bucket ke Archive, atur storageClass ke Archive. 
      acl: 'private', // Secara default, daftar kontrol akses (ACL) bucket adalah private. Untuk mengatur ACL bucket ke baca publik, atur acl ke public-read. 
      dataRedundancyType: 'LRS' // Secara default, tipe redundansi bucket adalah penyimpanan redundan lokal (LRS). Untuk mengatur 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();        

require 'aliyun/oss'
client = Aliyun::OSS::Client.new(
  // Contoh berikut menggunakan endpoint region China (Hangzhou). Ganti endpoint dengan yang sebenarnya.
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, 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')

// Buat 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) {
        // Pengecualian permintaan.
        if (clientException != null) {
            // Pengecualian sisi klien, seperti error jaringan.
            clientException.printStackTrace();
        }
        if (serviceException != null) {
            // Pengecualian sisi server.
            Log.e("KodeError", serviceException.getErrorCode());
            Log.e("IDPermintaan", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("PesanAsli", serviceException.getRawMessage());
        }
    }
});

#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* Inisialisasi informasi akun OSS. */
    
    /* Tetapkan yourEndpoint ke Endpoint region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur Endpoint ke https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    
    /* Tetapkan yourRegion ke region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur Region ke cn-hangzhou. */
    std::string Region = "yourRegion";

    /* Tentukan nama bucket, misalnya examplebucket. */
    std::string BucketName = "examplebucket";

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

    ClientConfiguration conf;
    conf.signatureVersion = SignatureVersionType::V4;
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh ini, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah diatur. */
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);
    client.SetRegion(Region);

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

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

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

    /* Lepaskan sumber daya jaringan. */
    ShutdownSdk();
    return 0;
}

// Buat permintaan untuk membuat bucket.
OSSCreateBucketRequest * create = [OSSCreateBucketRequest new];
// Atur nama bucket ke examplebucket.
create.bucketName = @"examplebucket";
// Atur daftar kontrol akses (ACL) bucket ke private.
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(@"berhasil membuat bucket!");
    } else {
        NSLog(@"gagal membuat bucket, error: %@", task.error);
    }
    return nil;
}];
// Blokir thread saat ini untuk menunggu tugas selesai.
// [createTask waitUntilFinished];          

#include "oss_api.h"
#include "aos_http_io.h"
/* Tetapkan yourEndpoint ke Endpoint region tempat bucket berada. Misalnya, jika bucket berada di region 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";
/* Tetapkan yourRegion ke region tempat bucket berada. Misalnya, jika bucket berada di region China (Hangzhou), atur region ke cn-hangzhou. */
const char *region = "yourRegion";

void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* Inisialisasi tipe aos_string_t dengan string char*. */
    aos_str_set(&options->config->endpoint, endpoint);
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh ini, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah diatur. */  
    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"));
    // Konfigurasikan dua parameter berikut.
    aos_str_set(&options->config->region, region);
    options->config->signature_version = 4;
    /* Menentukan apakah akan menggunakan CNAME untuk mengakses OSS. Nilai 0 berarti CNAME tidak digunakan. */
    options->config->is_cname = 0;
    /* Atur parameter jaringan, seperti periode timeout. */
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    /* Di titik masuk program, panggil metode aos_http_io_initialize untuk menginisialisasi sumber daya global seperti jaringan dan memori. */
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* Kolam memori untuk manajemen memori setara dengan apr_pool_t. Kode implementasi ada di pustaka apr. */
    aos_pool_t *pool;
    /* Buat kolam memori baru. Parameter kedua adalah NULL, yang berarti kolam baru tidak mewarisi dari kolam memori lain. */
    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 memori untuk opsi di kolam memori. */
    oss_client_options = oss_request_options_create(pool);
    /* Inisialisasi opsi klien 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 aos_string_t bucket. */
    aos_str_set(&bucket, bucket_name);
    /* Buat bucket. */
    resp_status = oss_create_bucket(oss_client_options, &bucket, oss_acl, &resp_headers);
    /* Periksa apakah permintaan berhasil. */
    if (aos_status_is_ok(resp_status)) {
        printf("berhasil membuat bucket\n");
    } else {
        printf("gagal membuat bucket\n");
    }
    /* Lepaskan kolam memori. Ini melepaskan memori yang dialokasikan untuk berbagai sumber daya selama permintaan. */
    aos_pool_destroy(pool);
    /* Lepaskan sumber daya global yang sebelumnya dialokasikan. */
    aos_http_io_deinitialize();
    return 0;
}