Mindestvoraussetzungen

Zum Ausführen des SDKs benötigen Sie Node 4.x+.

Client erstellen und Berechtigungsnachweise ableiten

Zum Herstellen einer Verbindung zu COS wird ein Client erstellt und durch Bereitstellen der Berechtigungsnachweisinformationen (API-Schlüssel, Serviceinstanz-ID und IBM Authentifizierungsendpunkt) konfiguriert. Diese Werte können auch automatisch aus einer Berechtigungsnachweisdatei oder aus Umgebungsvariablen abgeleitet werden.

Nach dem Generieren eines Serviceberechtigungsnachweises kann das daraus resultierende JSON-Dokument unter ~/.bluemix/cos_credentials gespeichert werden. Vom SDK wird diese Datei automatisch als Quelle für die Berechtigungsnachweise verwendet, sofern während der Clienterstellung nicht explizit andere Berechtigungsnachweise festgelegt werden. Wenn die Datei cos_credentials HMAC-Schlüssel enthält, wird die Authentifizierung vom Client mithilfe einer Signatur durchgeführt; andernfalls wird vom Client für die Authentifizierung der bereitgestellte API-Schlüssel mit einem Bearer-Token verwendet.

In der Abschnittsüberschrift default werden ein Standardprofil und zugeordnete Werte für Berechtigungsnachweise angegeben. Sie können in derselben gemeinsam genutzten Konfigurationsdatei weitere Profile erstellen und für jedes eigene Berechtigungsnachweisinformationen angeben. Im folgenden Beispiel wird eine Konfigurationsdatei mit dem Standardprofil dargestellt.

[default]
ibm_api_key_id = <DEFAULT_IBM_API_KEY>
ibm_service_instance_id = <DEFAULT_IBM_SERVICE_INSTANCE_ID>
ibm_auth_endpoint = <DEFAULT_IBM_AUTH_ENDPOINT>

Falls Sie eine Migration von AWS S3 durchführen, können Sie die Daten für die Berechtigungsnachweise aus ~/.aws/credentials im folgenden Format verwenden:

aws_access_key_id = <DEFAULT_ACCESS_KEY_ID>
aws_secret_access_key = <DEFAULT_SECRET_ACCESS_KEY>

Wenn sowohl ~/.bluemix/cos_credentials als auch ~/.aws/credentials vorhanden ist, genießt cos_credentials Vorrang.

Konfiguration initialisieren

const IBM = require('ibm-cos-sdk');
var config = {
    endpoint: '<endpoint>',
    apiKeyId: '<api-key>',
    serviceInstanceId: '<resource-instance-id>',
    signatureVersion: 'iam',
};
var cos = new IBM.S3(config);

Schlüsselwerte

• <endpoint>- Öffentlicher Endpunkt für Ihren Cloud-Objektspeicher (abrufbar über das Dashboard unter IBM Cloud ). Weitere Informationen zu Endpunkten enthält Endpunkte und Speicherpositionen.
• <api-key>- API-Schlüssel, der bei der Erstellung der Dienstanmeldedaten generiert wurde (für die Beispiele zum Erstellen und Löschen ist Schreibzugriff erforderlich)
• <resource-instance-id>- Ressourcen-ID für Ihren Cloud-Objektspeicher (verfügbar über die IBM Cloud-CLI oder das IBM Cloud-Dashboard )

Einen Protokollbereich erstellen

Auf eine Liste gültiger Bereitstellungscodes für LocationConstraint kann im Handbuch für Speicherklassen verwiesen werden.

function createBucket(bucketName) {
    console.log(`Creating new bucket: ${bucketName}`);
    return cos.createBucket({
        Bucket: bucketName,
        CreateBucketConfiguration: {
          LocationConstraint: 'us-standard'
        },
    }).promise()
    .then((() => {
        console.log(`Bucket: ${bucketName} created!`);
    }))
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• createBucket

Textobjekt erstellen

function createTextFile(bucketName, itemName, fileText) {
    console.log(`Creating new item: ${itemName}`);
    return cos.putObject({
        Bucket: bucketName,
        Key: itemName,
        Body: fileText
    }).promise()
    .then(() => {
        console.log(`Item: ${itemName} created!`);
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• putObject

Buckets auflisten

function getBuckets() {
    console.log('Retrieving list of buckets');
    return cos.listBuckets()
    .promise()
    .then((data) => {
        if (data.Buckets != null) {
            for (var i = 0; i < data.Buckets.length; i++) {
                console.log(`Bucket Name: ${data.Buckets[i].Name}`);
            }
        }
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• listBuckets

Elemente in Bucket auflisten

function getBucketContents(bucketName) {
    console.log(`Retrieving bucket contents from: ${bucketName}`);
    return cos.listObjects(
        {Bucket: bucketName},
    ).promise()
    .then((data) => {
        if (data != null && data.Contents != null) {
            for (var i = 0; i < data.Contents.length; i++) {
                var itemKey = data.Contents[i].Key;
                var itemSize = data.Contents[i].Size;
                console.log(`Item: ${itemKey} (${itemSize} bytes).`)
            }
        }
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• listObjects

Dateiinhalt eines bestimmten Elements abrufen

function getItem(bucketName, itemName) {
    console.log(`Retrieving item from bucket: ${bucketName}, key: ${itemName}`);
    return cos.getObject({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then((data) => {
        if (data != null) {
            console.log('File Contents: ' + Buffer.from(data.Body).toString());
        }
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• getObject

Element in Bucket löschen

function deleteItem(bucketName, itemName) {
    console.log(`Deleting item: ${itemName}`);
    return cos.deleteObject({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then(() =>{
        console.log(`Item: ${itemName} deleted!`);
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• deleteObject

Mehrere Elemente in Bucket löschen

Eine Löschanforderung kann maximal 1000 Schlüssel enthalten, die gelöscht werden sollen. Das Löschen von Objekten in Stapeln ist zwar sehr nützlich, um den Aufwand pro Anforderung zu reduzieren, gehen Sie beim Löschen einer großen Anzahl an Schlüsseln jedoch mit Sorgfalt vor, weil die Ausführung der Anforderung einige Zeit in Anspruch nehmen kann. Berücksichtigen Sie außerdem die Größe der Objekte, um eine angemessene Leistung zu gewährleisten.

function deleteItems(bucketName) {
    var deleteRequest = {
        "Objects": [
            { "Key": "deletetest/testfile1.txt" },
            { "Key": "deletetest/testfile2.txt" },
            { "Key": "deletetest/testfile3.txt" },
            { "Key": "deletetest/testfile4.txt" },
            { "Key": "deletetest/testfile5.txt" }
        ]
    }
    return cos.deleteObjects({
        Bucket: bucketName,
        Delete: deleteRequest
    }).promise()
    .then((data) => {
        console.log(`Deleted items for ${bucketName}`);
        console.log(data.Deleted);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• deleteObjects

Bucket löschen

function deleteBucket(bucketName) {
    console.log(`Deleting bucket: ${bucketName}`);
    return cos.deleteBucket({
        Bucket: bucketName
    }).promise()
    .then(() => {
        console.log(`Bucket: ${bucketName} deleted!`);
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• deleteBucket

Mehrteiligen Upload ausführen

function multiPartUpload(bucketName, itemName, filePath) {
    var uploadID = null;
    if (!fs.existsSync(filePath)) {
        log.error(new Error(`The file \'${filePath}\' does not exist or is not accessible.`));
        return;
    }
    console.log(`Starting multi-part upload for ${itemName} to bucket: ${bucketName}`);
    return cos.createMultipartUpload({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then((data) => {
        uploadID = data.UploadId;
        //begin the file upload
        fs.readFile(filePath, (e, fileData) => {
            //min 5MB part
            var partSize = 1024 * 1024 * 5;
            var partCount = Math.ceil(fileData.length / partSize);
            async.timesSeries(partCount, (partNum, next) => {
                var start = partNum * partSize;
                var end = Math.min(start + partSize, fileData.length);
                partNum++;
                console.log(`Uploading to ${itemName} (part ${partNum} of ${partCount})`);
                cos.uploadPart({
                    Body: fileData.slice(start, end),
                    Bucket: bucketName,
                    Key: itemName,
                    PartNumber: partNum,
                    UploadId: uploadID
                }).promise()
                .then((data) => {
                    next(e, {ETag: data.ETag, PartNumber: partNum});
                })
                .catch((e) => {
                    cancelMultiPartUpload(bucketName, itemName, uploadID);
                    console.error(`ERROR: ${e.code} - ${e.message}\n`);
                });
            }, (e, dataPacks) => {
                cos.completeMultipartUpload({
                    Bucket: bucketName,
                    Key: itemName,
                    MultipartUpload: {
                        Parts: dataPacks
                    },
                    UploadId: uploadID
                }).promise()
                .then(console.log(`Upload of all ${partCount} parts of ${itemName} successful.`))
                .catch((e) => {
                    cancelMultiPartUpload(bucketName, itemName, uploadID);
                    console.error(`ERROR: ${e.code} - ${e.message}\n`);
                });
            });
        });
    })
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}
function cancelMultiPartUpload(bucketName, itemName, uploadID) {
    return cos.abortMultipartUpload({
        Bucket: bucketName,
        Key: itemName,
        UploadId: uploadID
    }).promise()
    .then(() => {
        console.log(`Multi-part upload aborted for ${itemName}`);
    })
    .catch((e)=>{
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• abortMultipartUpload
• completeMultipartUpload
• createMultipartUpload
• uploadPart

Erstellen einer Sicherungsrichtlinie

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config values
const apiKey = '<API_KEY>';
const sourceBucketName = '< SOURCE_BUCKET_NAME>';
const backupVaultCrn = '<BACKUP_VAULT_CRN>';
const policyName = '<BACKUP_POLICY_NAME>';
async function  createBackupPolicy () {
  try {
    // Authenticator and client setup
    const authenticator = new IamAuthenticator({ apikey: apiKey });
    const rcClient = new ResourceConfigurationV1({ authenticator });
    // Create backup policy
    const response = await rcClient.createBackupPolicy({
      bucket: sourceBucketName,
      policyName: policyName,
      targetBackupVaultCrn: backupVaultCrn,
      backupType: “continuous”,
      initialRetention: {delete_after_days:1},
    });
    console.log('Backup  policy created successfully: ‘, response.result);
  } catch (err) {
    console.error('Error:', err);
  }
}
// Run the function
createBackupPolicy ();

Auflistung einer Sicherungsrichtlinie

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const sourceBucketName = '<SOURCE_BUCKET_NAME>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function listBackupPolicies() {
  try {
    // List all backup policies
    const listResponse = await rcClient.listBackupPolicies({
      bucket: sourceBucketName,
    });
    console.log('\n List of backup policies:');
    const policies = listResponse.result.backup_policies || [];
    policies.forEach(policy => console.log(policy));
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
listBackupPolicies();

Erstellen Sie eine Backup-Richtlinie

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const sourceBucketName = '<SOURCE_BUCKET_NAME>';
const policyId = '<POLICY_ID>'; // Policy ID to retrieve backup Policy
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function fetchBackupPolicy () {
  try {
    // Fetch backup policy
    const getResponse = await rcClient.getBackupPolicy({
      bucket: sourceBucketName,
      policyId: policyId,
    });
    console.log('\nFetched Backup Policy Details:');
    console.log(getResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
fetchBackupPolicy ();

Löschen einer Sicherungsrichtlinie

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const sourceBucketName = '<SOURCE_BUCKET_NAME>';
const policyId = '<POLICY_ID_TO_DELETE>'; // Policy ID of the policy to be deleted
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function deleteBackupPolicy() {
try {
    // Delete backup policy
    await rcClient.deleteBackupPolicy({
      bucket: sourceBucketName,
      policyId: policyId,
    });
    console.log(`Backup policy '${policyId}' deleted successfully.`);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
deleteBackupPolicy ();

Erstellen eines Backup Tresors

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const serviceInstanceId = '<SERVICE_INSTANCE_ID>';
const region = '<REGION>';
const backupVaultName = <BACKUP_VAULT_NAME>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function createBackupVault() {
  try {
    const createResponse = await rcClient.createBackupVault({
      serviceInstanceId: serviceInstanceId,
      backupVaultName: backupVaultName,
      region: region,
    });
    console.log('Backup vault created:');
    console.log(createResponse.result);
  } catch (error) {
    console.error('Error creating backup vault:', error);
  }
}
// Run the function
createBackupVault();

Auflistung von Backup-Tresoren

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const serviceInstanceId = '<SERVICE_INSTANCE_ID>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function listBackupVaults() {
  try {
    // List backup vaults
    const listResponse = await rcClient.listBackupVaults({
      serviceInstanceId: serviceInstanceId,
    });
    console.log('List of backup vaults:');
    console.log(listResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
listBackupVaults ();

Backup-Tresore erhalten

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>'; // Name of the backup vault to fetch
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function fetchBackupVault () {
  try {
    // Get backup vault
    const getResponse = await rcClient.getBackupVault({
      backupVaultName: backupVaultName,
    });
    console.log('Backup vault details:');
    console.log(getResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
fetchBackupVault ();

Backup-Tresore aktualisieren

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1');
// Config
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>'; // Keep consistent for create + update
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function updateBackupVault() {
  try {
    // Update backup vault to disable tracking and monitoring
    const patch = {
      activity_tracking: {
        management_events: false,
      },
      metrics_monitoring: {
        usage_metrics_enabled: false,
      },
    };
    const updateResponse = await rcClient.updateBackupVault({
      backupVaultName: backupVaultName,
      backupVaultPatch: patch,
    });
    console.log(`Backup vault updated. Status code: ${updateResponse.status}`);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
updateBackupVault ();

Löschen eines Sicherungsdepots

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function deleteBackupVault() {
  try {
    // Delete the backup vault
    await rcClient.deleteBackupVault({
      backupVaultName: backupVaultName,
    });
    console.log(`Backup vault '${backupVaultName}' deleted successfully.`);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
deleteBackupVault();

Auflistung der Verwertungsspannen

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function listRecoveryRanges() {
  try {
    // List recovery ranges
    const recoveryRangesResponse = await rcClient.listRecoveryRanges({
      backupVaultName: backupVaultName,
    });
    console.log('Recovery Ranges:');
    console.log(recoveryRangesResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
listRecoveryRanges();

Erholungsbereich erhalten

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const recoveryRangeId = '<RECOVERY_RANGE_ID>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function fetchRecoveryRangeInfo() {
try {
    // Fetch details of the recovery range
    const recoveryRangeId = createResponse.result.recovery_range_id;  // Assuming the recovery range info is part of the response
    const getRecoveryRangeResponse = await rcClient.getSourceResourceRecoveryRange({
      backupVaultName: backupVaultName,
      recoveryRangeId: recoveryRangeId,
    });
    console.log('Recovery Range Details:');
    console.log(getRecoveryRangeResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
fetchRecoveryRangeInfo();

Wiederherstellungsbereich aktualisieren

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1');
// Config
const apiKey = '<API_KEY>';
const backupVaultCrn = '<BACKUP_VAULT_CRN>';
const recoveryRangeId = '<RECOVERY_RANGE_ID>';
const policyId = '<POLICY_ID>';
// Setup authenticator and client
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
async function patchRecoveryRange() {
  try {
    // Patch the recovery range retention
    const patchResponse = await rcClient.patchSourceResourceRecoveryRange({
      backupVaultName: backupVaultName,
      recoveryRangeId: recoveryRangeId,
      retention: {
          delete_after_days: 99
        }
    });
    console.log('Recovery range updated successfully:');
    console.log(patchResponse.result);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
patchRecoveryRange ();

Initiieren einer Wiederherstellung

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Configuration
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
const recoveryRangeId = '<RECOVERY_RANGE_ID>';
const targetBucketCrn = '<TARGET_BUCKET_CRN>';
const restorePointInTime = '<RESTORE_POINT_TIME>';
const endpoint = '<COS_ENDPOINT>';
// Setup authenticator and clients
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
rcClient.setServiceUrl("SERVICE_URL");
async function initiateRestore () {
  try {
    // Initiate restore
    const createRestoreResponse = await rcClient.createRestore({
      backupVaultName: backupVaultName,
      recoveryRangeId: recoveryRangeId,
      restoreType: 'in_place',
      restorePointInTime: restorePointInTime,
      targetResourceCrn: targetBucketCrn,
    });
    const restoreId = createRestoreResponse.result.restore_id;
    console.log(`Restore initiated with ID: ${restoreId}`);
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the function
initiateRestore ();

Auflistung Wiederherstellen

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Config
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
// Auth & Clients
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
rcClient.setServiceUrl("SERVICE_URL");
async function listRestore()  {
  try {
    // List restore operations
    const listRestoreResp = await rcClient.listRestores({
      backupVaultName: backupVaultName
    });
    console.log('Restore operations:', listRestoreResp.result);
  } catch (err) {
    console.error('Error occurred:', err);
  }
};
// Run the function
listRestore();

Details zur Wiederherstellung abrufen

const { IamAuthenticator } = require('ibm-cloud-sdk-core');
const ResourceConfigurationV1 = require('ibm-cos-sdk-config/resource-configuration/v1')
// Configuration
const apiKey = '<API_KEY>';
const backupVaultName = '<BACKUP_VAULT_NAME>';
const restoreId = '<RESTORE_ID>';
const authenticator = new IamAuthenticator({ apikey: apiKey });
const rcClient = new ResourceConfigurationV1({ authenticator });
rcClient.setServiceUrl("SERVICE_URL");
async function getRestore()  {
  try {
    // Get specific restore
    const restoreDetails = await rcClient.getRestore({
      backupVaultName: backupVaultName,
      restoreId: restoreId
    });
    console.log('Restore details:', restoreDetails.result);
  } catch (err) {
    console.error('Error:', err);
  }
}
getRestore();

Erstellen Sie einen neuen Cos-Bucket mit aktivierter Objektsperre (in Kürze verfügbar)

function createBucket(bucketName) {
    console.log(`Creating new bucket: ${bucketName}`);
    return cos.createBucket({
        Bucket: bucketName,
        ObjectLockEnabledForBucket: true,
        CreateBucketConfiguration: {
            LocationConstraint: ''
          },
    }).promise()
    .then((() => {
        console.log(`Bucket: ${bucketName} created!`);
    }))
    .catch((e) => {
        console.error(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Objektsperrenkonfiguration mit Compliance-Modus auf COS-Bucket anwenden (in Kürze verfügbar)

function putObjectLockConfigurationOnBucket(bucketName) {
    console.log(`Putting Objectlock Configuration on : ${bucketName}`);
    // Putting objectlock configuration
    var defaultRetention = {Mode: 'COMPLIANCE', Days: 1}
    var objectLockRule = {DefaultRetention : defaultRetention}
    var param = {ObjectLockEnabled: 'Enabled', Rule: objectLockRule}
    return cos.putObjectLockConfiguration({
        Bucket: bucketName,
        ObjectLockConfiguration: param
    }).promise()
    .then(() => {
        console.log(`Object lock Configurtion added!!`);
        logDone();
    })
    .catch(logError);
}

Objektsperrenkonfiguration mit Governance-Modus auf COS-Bucket setzen (in Kürze verfügbar)

function putObjectLockConfigurationWithGovernanceModeOnBucket(bucketName) {
    console.log(`Putting Objectlock Configuration on : ${bucketName}`);
    // Putting objectlock configuration
    var defaultRetention = {Mode: 'GOVERNANCE', Days: 1}
    var objectLockRule = {DefaultRetention : defaultRetention}
    var param = {ObjectLockEnabled: 'Enabled', Rule: objectLockRule}
    return cos.putObjectLockConfiguration({
        Bucket: bucketName,
        ObjectLockConfiguration: param
    }).promise()
    .then(() => {
        console.log(`Object lock Configurtion with Governance mode added!!`);
        logDone();
    })
    .catch(logError);
}

Objektsperrkonfiguration für COS-Bucket abrufen (in Kürze verfügbar)

function getObjectLockConfigurationonBucket(bucketName) {
    console.log(`Getting Objectlock Configuration for : ${bucketName}`);
    // Getting objectlock configuration
    return cos.getObjectLockConfiguration({
        Bucket: bucketName,
    }).promise()
    .then((data) => {
        console.log(`objectlock configuration`);
        console.log( JSON.stringify(data.ObjectLockConfiguration, null, "    ") );
        logDone();
    })
    .catch(logError);
}

Objekt mit Governance-Modus in COS-Bucket hochladen (in Kürze verfügbar)

function createTextFile(bucketName, itemName, fileText) {
    console.log(`Creating new item: ${itemName}`);
    return cos.putObject({
        Bucket: bucketName,
        Key: itemName,
        Body: fileText
    }).promise()
    .then(() => {
        console.log(`Item: ${itemName} created!`);
        logDone();
    })
    .catch(logError);
}

Objektsperre mit Compliance-Modus für das Objekt aktivieren (in Kürze verfügbar)

function putObjectLockRetention(bucketName,keyName) {
    console.log(`Putting Objectlock Retention on : ${keyName}`);
    var inFiveSecond = (new Date(Date.now() + (1000 * 5)))
    var rule = {Mode: 'COMPLIANCE', RetainUntilDate: inFiveSecond}
     // Putting objectlock retention
    return cos.putObjectRetention({
        Bucket: bucketName,
        Key: keyName,
        Retention: rule
    }).promise()
    .then(() => {
        console.log(`Object lock Retention added!!`);
        logDone();
    })
    .catch(logError);
}

Objektsperre mit Governance-Modus für das Objekt aktivieren (in Kürze verfügbar)

function putObjectLockRetentionWithGovernanceMode(bucketName,keyName) {
    console.log(`Putting Objectlock Retention on : ${keyName}`);
    var inFiveSecond = (new Date(Date.now() + (1000 * 5)))
    var rule = {Mode: 'GOVERNANCE', RetainUntilDate: inFiveSecond}
     // Putting objectlock retention
    return cos.putObjectRetention({
        Bucket: bucketName,
        Key: keyName,
        Retention: rule
    }).promise()
    .then(() => {
        console.log(`Object lock Retention with governance mode added!!`);
        logDone();
    })
    .catch(logError);
}

Objektsperre beibehalten (in Kürze verfügbar)

function getObjectLockRetention(bucketName,keyName) {
    console.log(`Getting Objectlock Retention for : ${keyName}`);
    // Getting objectlock retention
    return cos.getObjectRetention({
        Bucket: bucketName,
        Key: keyName
    }).promise()
    .then((data) => {
        console.log(`Objectlock retention for : ${keyName} `);
        console.log( JSON.stringify(data.Retention, null, "    ") );
        logDone();
    })
    .catch(logError);
}

Objektsperre „Legal Hold“ setzen (in Kürze verfügbar)

function putObjectLocklegalHold(bucketName,keyName) {
    console.log(`Putting Objectlock legal-hold status ON for  : ${keyName}`);
     // Putting objectlock legal-hold status
    return cos.putObjectlegalHold({
        Bucket: bucketName,
        Key: keyName,
        LegalHold: {Status: 'ON'}
    }).promise()
    .then(() => {
        console.log(`Object lock legal-hold added!!`);
        logDone();
    })
    .catch(logError);
}

Objektsperre „Legal Hold“ erhalten (in Kürze verfügbar)

function getObjectLocklegalHold(bucketName,keyName) {
    console.log(`Getting Objectlock legal-hold for : ${keyName}`);
    // Getting objectlock legal-hold
    return cos.getObjectlegal-hold({
        Bucket: bucketName,
        Key: keyName
    }).promise()
    .then((data) => {
        console.log(`Objectlock legal-hold for : ${keyName} `);
        console.log( JSON.stringify(data.legal-hold, null, "    ") );
        logDone();
    })
    .catch(logError);
}

Löschen eines Objekts mit Objektsperr-Governance-Modus mithilfe von Bypass-Governance (in Kürze verfügbar)

function deleteObjectWithGovernanceMode(bucketName,keyName) {
    console.log(`Deleting an object with bypass governance : ${keyName}`);
    // Deleting an object with bypass governance
    return cos.deleteObject({
     Bucket: bucketName,
     Key: objectKey,
     BypassGovernanceRetention: true,
    }).promise()
    .then(() => {
       console.log("Object deleted");
    })
    .catch(err => {
       console.error("Error deleting object:", err);
    });
}

Vorbereitende Schritte

Die folgenden Elemente sind erforderlich, um einen Bucket mit aktivierter Key-Protect-Funktion zu erstellen:

• Ein Key Protect-Service wird bereitgestellt
• Ein Stammschlüssel ist verfügbar (entweder generiert oder importiert)

Cloudressourcenname für Stammschlüssel abrufen

1. Rufen Sie die Instanz-ID für den Key Protect-Service ab.
2. Verwenden Sie die Key Protect-API, um alle verfügbaren Schlüssel abzurufen.
   • Sie können entweder curl-Befehle oder einen API-REST-Client wie zum Beispiel Postman für den Zugriff auf die Key Protect-API verwenden.
3. Rufen Sie den Cloudressourcennamen des Stammschlüssels ab, mit dem Sie Key Protect für das Bucket aktivieren. Der Cloudressourcenname ähnelt der folgenden Zeichenfolge:

crn:v1:bluemix:public:kms:us-south:a/3d624cd74a0dea86ed8efe3101341742:90b6a1db-0fe1-4fe9-b91e-962c327df531:key:0bg3e33e-a866-50f2-b715-5cba2bc93234

Bucket während Aktivierung von Key Protect erstellen

function createBucketKP(bucketName) {
    console.log(`Creating new encrypted bucket: ${bucketName}`);
    return cos.createBucket({
        Bucket: bucketName,
        CreateBucketConfiguration: {
          LocationConstraint: '<bucket-location>'
        },
        IBMSSEKPEncryptionAlgorithm: '<algorithm>',
        IBMSSEKPCustomerRootKeyCrn: '<root-key-crn>'
    }).promise()
    .then((() => {
        console.log(`Bucket: ${bucketName} created!`);
        logDone();
    }))
    .catch(logError);
}

Schlüsselwerte

• <bucket-location>- Region oder Standort für Ihren Bucket ( Key Protect ist nur in bestimmten Regionen verfügbar. Stellen Sie sicher, dass Ihr Standort mit dem Key Protect-Service übereinstimmt). Auf eine Liste gültiger Bereitstellungscodes für LocationConstraint kann im Handbuch für Speicherklassen verwiesen werden.
• <algorithm>- Der Verschlüsselungsalgorithmus, der für neue Objekte verwendet wird, die dem Bucket hinzugefügt werden (Standard ist „ AES256 “).
• <root-key-crn>- CRN des Root-Schlüssels, der über den Dienst „ Key Protect “ abgerufen wird.

SDK-Referenzen

• createBucket

Lebenszykluskonfiguration eines Buckets anzeigen

function getLifecycleConfiguration(bucketName) {
    return cos.getBucketLifecycleConfiguration({
        Bucket: bucketName
    }).promise()
    .then((data) => {
        if (data != null) {
            console.log(`Retrieving bucket lifecycle config from: ${bucketName}`);
            console.log(JSON.stringify(data, null, 4));
        }
        else {
            console.log(`No lifecycle configuration for ${bucketName}`);
        }
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• getBucketLifecycleConfiguration

Lebenszykluskonfiguration erstellen

Ausführliche Informationen zur Strukturierung der Regeln für Lebenszykluskonfigurationen finden Sie in der API-Referenz.

function createLifecycleConfiguration(bucketName) {
    //
    var config = {
        Rules: [{
            Status: 'Enabled',
            ID: '<policy-id>',
            Filter: {
                Prefix: ''
            },
            Transitions: [{
                Days: <number-of-days>,
                StorageClass: 'GLACIER'
            }]
        }]
    };
    return cos.putBucketLifecycleConfiguration({
        Bucket: bucketName,
        LifecycleConfiguration: config
    }).promise()
    .then(() => {
        console.log(`Created bucket lifecycle config for: ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Schlüsselwerte

• <policy-id>- Name der Lebenszyklusrichtlinie (muss eindeutig sein)
• <number-of-days>- Anzahl der Tage, an denen die wiederhergestellte Datei aufbewahrt werden soll

SDK-Referenzen

• putBucketLifecycleConfiguration

Lebenszykluskonfiguration eines Buckets löschen

function deleteLifecycleConfiguration(bucketName) {
    return cos.deleteBucketLifecycle({
        Bucket: bucketName
    }).promise()
    .then(() => {
        console.log(`Deleted bucket lifecycle config from: ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• deleteBucketLifecycle

Objekt vorübergehend wiederherstellen

Ausführliche Informationen zum Wiederherstellen von Anforderungsparametern finden Sie in der API-Referenz.

function restoreItem(bucketName, itemName) {
    var params = {
        Bucket: bucketName,
        Key: itemName,
        RestoreRequest: {
            Days: <number-of-days>,
            GlacierJobParameters: {
                Tier: 'Bulk'
            },
        }
    };
    return cos.restoreObject(params).promise()
    .then(() => {
        console.log(`Restoring item: ${itemName} from bucket: ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Schlüsselwerte

• <number-of-days>- Anzahl der Tage, an denen die wiederhergestellte Datei aufbewahrt werden soll

SDK-Referenzen

• restoreObject

HEAD-Informationen für Objekt anzeigen

function getHEADItem(bucketName, itemName) {
    return cos.headObject({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then((data) => {
        console.log(`Retrieving HEAD for item: ${itemName} from bucket: ${bucketName}`);
        console.log(JSON.stringify(data, null, 4));
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

SDK-Referenzen

• headObject

PUT zum Aktualisieren der Metadaten verwenden

Hinweis: Die Anfrage „ PUT “ überschreibt den bestehenden Inhalt des Objekts; daher muss dieses zunächst heruntergeladen und anschließend mit den neuen Metadaten erneut hochgeladen werden.

function updateMetadataPut(bucketName, itemName, metaValue) {
    console.log(`Updating metadata for item: ${itemName}`);
    //retrieve the existing item to reload the contents
    return cos.getObject({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then((data) => {
        //set the new metadata
        var newMetadata = {
            newkey: metaValue
        };
        return cos.putObject({
            Bucket: bucketName,
            Key: itemName,
            Body: data.Body,
            Metadata: newMetadata
        }).promise()
        .then(() => {
            console.log(`Updated metadata for item: ${itemName} from bucket: ${bucketName}`);
        })
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

COPY zum Aktualisieren der Metadaten verwenden

function updateMetadataCopy(bucketName, itemName, metaValue) {
    console.log(`Updating metadata for item: ${itemName}`);
    //set the copy source to itself
    var copySource = bucketName + '/' + itemName;
    //set the new metadata
    var newMetadata = {
        newkey: metaValue
    };
    return cos.copyObject({
        Bucket: bucketName,
        Key: itemName,
        CopySource: copySource,
        Metadata: newMetadata,
        MetadataDirective: 'REPLACE'
    }).promise()
    .then((data) => {
        console.log(`Updated metadata for item: ${itemName} from bucket: ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Schutzkonfiguration für vorhandenes Bucket hinzufügen

Objekte, die in ein geschütztes Bucket geschrieben wurden, können erst gelöscht werden, nachdem die Schutzfrist abgelaufen ist und alle Beweissicherungsvermerke für das Objekt entfernt wurden. Einem Objekt wird der Standardaufbewahrungswert des Buckets zugewiesen, sofern für das Objekt bei seiner Erstellung nicht ein objektspezifischer Wert angegeben wurde. Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

Die unterstützten Mindest- und Maximalwerte für die Einstellungen MinimumRetention, DefaultRetention und MaximumRetention der Aufbewahrungsdauer lauten 0 Tage und 365243 Tage (1000 Jahre).

function addProtectionConfigurationToBucket(bucketName) {
    console.log(`Adding protection to bucket ${bucketName}`);
    return cos.putBucketProtectionConfiguration({
        Bucket: bucketName,
        ProtectionConfiguration: {
            'Status': 'Retention',
            'MinimumRetention': {'Days': 10},
            'DefaultRetention': {'Days': 100},
            'MaximumRetention': {'Days': 1000}
        }
    }).promise()
    .then(() => {
        console.log(`Protection added to bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Schutz für Bucket überprüfen

function getProtectionConfigurationOnBucket(bucketName) {
    console.log(`Retrieve the protection on bucket ${bucketName}`);
    return cos.getBucketProtectionConfiguration({
        Bucket: bucketName
    }).promise()
    .then((data) => {
        console.log(`Configuration on bucket ${bucketName}:`);
        console.log(data);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Geschütztes Objekt hochladen

Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

function putObjectAddLegalHold(bucketName, objectName, legalHoldId) {
    console.log(`Add legal hold ${legalHoldId} to ${objectName} in bucket ${bucketName} with a putObject operation.`);
    return cos.putObject({
        Bucket: bucketName,
        Key: objectName,
        Body: 'body',
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then((data) => {
        console.log(`Legal hold ${legalHoldId} added to object ${objectName} in bucket ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}
function copyProtectedObject(sourceBucketName, sourceObjectName, destinationBucketName, newObjectName, ) {
    console.log(`Copy protected object ${sourceObjectName} from bucket ${sourceBucketName} to ${destinationBucketName}/${newObjectName}.`);
    return cos.copyObject({
        Bucket: destinationBucketName,
        Key: newObjectName,
        CopySource: sourceBucketName + '/' + sourceObjectName,
        RetentionDirective: 'Copy'
    }).promise()
    .then((data) => {
        console.log(`Protected object copied from ${sourceBucketName}/${sourceObjectName} to ${destinationBucketName}/${newObjectName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Beweissicherungsvermerk zu geschütztem Objekt hinzufügen oder aus geschütztem Objekt entfernen

Das Objekt kann bis zu 100 Beweissicherungsvermerke unterstützen:

• Die Kennung eines Beweissicherungsvermerks besteht aus einer Zeichenfolge mit maximal 64 Zeichen Länge und einer Mindestlänge von einem Zeichen. Zulässige Zeichen sind Buchstaben, Zahlen, !, _, ., *, (, ), - und '.
• Wenn durch das Hinzufügen des angegebenen Beweissicherungsvermerks der Grenzwert von insgesamt 100 Beweissicherungsvermerken für das Objekt überschritten wird, dann wird der neue Beweissicherungsvermerk nicht hinzugefügt und das System gibt den Fehler 400 aus.
• Wenn eine Kennung zu lang ist, dann wird sie nicht zum Objekt hinzugefügt und das System gibt den Fehler 400 zurück.
• Wenn eine Kennung ungültige Zeichen enthält, dann wird sie nicht zum Objekt hinzugefügt und das System gibt den Fehler 400 zurück.
• Wenn eine Kennung für ein Objekt bereits verwendet wird, dann wird der vorhandene Beweissicherungsvermerk nicht geändert und in der Antwort wird angegeben, dass die Kennung bereits belegt ist (Fehler 409).
• Wenn ein Objekt keine Metadaten für die Aufbewahrungsdauer aufweist, wird der Fehler 400 zurückgegeben und das Hinzufügen oder Entfernen eines Beweissicherungsvermerks ist nicht zulässig.

Der Benutzer, der einen Beweissicherungsvermerk hinzufügt oder entfernt, muss über die Berechtigungen für Manager für dieses Bucket verfügen.

function addLegalHoldToObject(bucketName, objectName, legalHoldId) {
    console.log(`Adding legal hold ${legalHoldId} to object ${objectName} in bucket ${bucketName}`);
    return cos.client.addLegalHold({
        Bucket: bucketName,
        Key: objectId,
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then(() => {
        console.log(`Legal hold ${legalHoldId} added to object ${objectName} in bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}
function deleteLegalHoldFromObject(bucketName, objectName, legalHoldId) {
    console.log(`Deleting legal hold ${legalHoldId} from object ${objectName} in bucket ${bucketName}`);
    return cos.client.deleteLegalHold({
        Bucket: bucketName,
        Key: objectId,
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then(() => {
        console.log(`Legal hold ${legalHoldId} deleted from object ${objectName} in bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Aufbewahrungsdauer eines geschützten Objekts erweitern

Die Aufbewahrungsdauer eines Objekts kann nur verlängert werden. Sie kann gegenüber dem momentan konfigurierten Wert nicht verkürzt werden.

Der Wert für die Verlängerung der Aufbewahrungsdauer kann auf die folgenden drei Arten festgelegt werden:

• Hinzufügen zusätzlicher Zeit zum aktuellen Wert (Additional-Retention-Period oder ähnliche Methode)
• Definieren einer neuen Verlängerungszeitdauer in Sekunden (Extend-Retention-From-Current-Time oder ähnliche Methode)
• Definieren eines neuen Ablaufdatums für die Aufbewahrung des Objekts (New-Retention-Expiration-Date oder ähnliche Methode)

Die in den Objektmetadaten momentan gespeicherte Aufbewahrungsdauer wird entweder um die angegebene zusätzliche Zeitdauer verlängert oder durch den neuen Wert ersetzt. Welche Methode verwendet wird, hängt von dem Parameter ab, der in der Anforderung für extendRetention festgelegt wird. In allen Fällen wird der Parameter für die Verlängerung des Aufbewahrungszeitraums mit den Angaben für den aktuellen Aufbewahrungszeitraum verglichen; der erweiterte Parameter wird nur akzeptiert, wenn der aktualisierte Aufbewahrungszeitraum größer ist als der aktuelle Aufbewahrungszeitraum.

Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

function extendRetentionPeriodOnObject(bucketName, objectName, additionalSeconds) {
    console.log(`Extend the retention period on ${objectName} in bucket ${bucketName} by ${additionalSeconds} seconds.`);
    return cos.extendObjectRetention({
        Bucket: bucketName,
        Key: objectName,
        AdditionalRetentionPeriod: additionalSeconds
    }).promise()
    .then((data) => {
        console.log(`New retention period on ${objectName} is ${data.RetentionPeriod}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Beweissicherungsvermerke für geschütztes Objekt auflisten

Nach dem Ausführen dieser Operation wird Folgendes zurückgegeben:

• Objekterstellungsdatum
• Aufbewahrungsdauer des Objekts in Sekunden
• Berechnetes Ablaufdatum der Aufbewahrung auf Basis der Aufbewahrungsdauer und des Erstellungsdatums
• Liste der Beweissicherungsvermerke
• Kennung des Beweissicherungsvermerks
• Zeitmarke für Anwendung des Beweissicherungsvermerks

Wenn für das Objekt keine Beweissicherungsvermerke definiert wurden, dann gibt das System ein leeres Element LegalHoldSet zurück. Wurde keine Aufbewahrungsdauer für das Objekt angegeben, dann wird der Fehler 404 zurückgegeben.

function listLegalHoldsOnObject(bucketName, objectName) {
    console.log(`List all legal holds on object ${objectName} in bucket ${bucketName}`);
    return cos.listLegalHolds({
        Bucket: bucketName,
        Key: objectId
    }).promise()
    .then((data) => {
        console.log(`Legal holds on bucket ${bucketName}: ${data}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

Erstellen einer gehosteten statischen Website

Für diese Operation sind Berechtigungen erforderlich, da nur der Bucketeigner normalerweise berechtigt ist, ein Bucket zum Hosten einer statischen Website zu konfigurieren. Die Parameter bestimmen das Standardsuffix für Besucher der Site sowie ein optionales Fehlerdokument.

var websiteParams = {
  Bucket: "bucketName",
  WebsiteConfiguration: {
    ErrorDocument: {
      Key: "error.html"
    },
    IndexDocument: {
      Suffix: "index.html"
    }
  }
};
function putBucketWebsiteConfiguration(websiteParams) {
  return cos.putBucketWebsite({websiteParams}).promise()
    .then((data) => {
       console.log(`Website configured for ${bucketName}`);
    })
    .catch((e) => {
       console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}