Gestione della replica turbo

Vai ai concetti

In questa pagina viene descritto come utilizzare la funzionalità di replica turbo in un bucket a doppia area geografica.

Prerequisiti

I prerequisiti possono variare in base allo strumento utilizzato:

console

Per completare questa guida utilizzando Google Cloud Console, devi disporre delle autorizzazioni IAM appropriate. Per utilizzare questa funzionalità, devi avere o creare un bucket in una località con due aree geografiche. Se il bucket a cui vuoi accedere esiste in un progetto non creato da te, potresti dover chiedere al proprietario del progetto di assegnarti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta Autorizzazioni IAM per Google Cloud Console.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni specifiche e limitate.

Riga di comando

Per completare questa guida utilizzando un'utilità a riga di comando, devi disporre delle autorizzazioni IAM appropriate. Per utilizzare questa funzionalità, devi avere o creare un bucket in una località con due aree geografiche. Se il bucket a cui vuoi accedere esiste in un progetto non creato da te, potresti dover chiedere al proprietario del progetto di assegnarti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta Autorizzazioni IAM per comandi gsutil.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni specifiche e limitate.

Esempi di codice

Per completare questa guida utilizzando le librerie client di Cloud Storage, devi disporre delle autorizzazioni IAM appropriate. Per utilizzare questa funzionalità, devi avere o intendi creare un bucket in una località con doppia area geografica. Se il bucket a cui vuoi accedere esiste in un progetto non creato da te, potresti dover chiedere al proprietario del progetto di assegnarti un ruolo contenente le autorizzazioni necessarie. Se non diversamente indicato, le richieste della libreria client vengono effettuate tramite l'API JSON.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per i metodi JSON.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni specifiche e limitate.

API REST

API JSON

Per completare questa guida utilizzando l'API JSON, devi disporre delle autorizzazioni IAM appropriate. Per utilizzare questa funzionalità, devi avere o creare un bucket in una località con due aree geografiche. Se il bucket a cui vuoi accedere esiste in un progetto non creato da te, potresti dover chiedere al proprietario del progetto di assegnarti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per i metodi JSON.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni specifiche e limitate.

API XML

Questa funzionalità non può essere gestita tramite l'API XML. Usa l'API JSON.

Controllare lo stato di replica di un bucket

Per controllare l'RPO o lo stato della replica di un bucket, completa le seguenti istruzioni:

console

  1. In Google Cloud Console, vai alla pagina Browser di Cloud Storage.

    Vai al browser

  2. Nell'elenco dei bucket, fai clic sul nome del bucket da verificare.

  3. Fai clic sulla scheda Configurazione.

  4. Se la replica turbo è abilitata nel bucket, Replication è impostata su Turbo.

Riga di comando

Utilizza il comando gsutil rpo get:

gsutil rpo get gs://BUCKET_NAME/

Dove:

  • BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

In caso di esito positivo, la risposta sarà simile al seguente esempio:

gs://my-bucket: ASYNC_TURBO

Esempi di codice

C++

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto metadata = client.GetBucketMetadata(bucket_name);
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "RPO is " << metadata->rpo() << " for bucket "
            << metadata->name() << "\n";
}

C#

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C# .


using System;
using Google.Cloud.Storage.V1;

public class GetRpoSample
{
    public string GetRpo(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var rpo = storage.GetBucket(bucketName).Rpo;
        Console.WriteLine($"The RPO Setting of bucket {bucketName} is {rpo}.");

        return rpo;
    }
}

Go

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Go.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// getRPO gets the current RPO (Recovery Point Objective) setting
// for the bucket, either "DEFAULT" or "ASYNC_TURBO".
func getRPO(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	attrs, err := client.Bucket(bucketName).Attrs(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).Attrs: %v", bucketName, err)
	}
	fmt.Fprintf(w, "RPO is %s for %v", attrs.RPO, bucketName)
	return nil
}

Java

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Java.

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class GetBucketRpo {
  public static void getBucketRpo(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    String rpo = bucket.getRpo().toString();

    System.out.println("The RPO setting of bucket " + bucketName + " is " + rpo);
  }
}

Node.js

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The name of your GCS bucket in a dual-region
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function getRPO() {
  // Gets Bucket Metadata and prints RPO value (either 'default' or 'async_turbo').
  // If RPO is undefined, the bucket is a single region bucket
  const [metadata] = await storage.bucket(bucketName).getMetadata();
  console.log(`RPO is ${metadata.rpo} for ${bucketName}.`);
}

getRPO();

PHP

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Get the bucket's recovery point objective (RPO) setting.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function get_rpo($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    printf(
        'The bucket\'s RPO value is: %s.' . PHP_EOL,
        $bucket->info()['rpo']
    );
}

Python

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Python.


from google.cloud import storage
from google.cloud.storage.constants import RPO_DEFAULT

def get_rpo(bucket_name):
    """Gets the RPO of the bucket"""
    # The ID of your GCS bucket
    # bucket_name = "my-bucket"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    bucket.rpo = RPO_DEFAULT
    rpo = bucket.rpo

    print(f"RPO for {bucket.name} is {rpo}.")

Ruby

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

def get_rpo bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name

  puts "The RPO setting of bucket '#{bucket_name}' is #{bucket.rpo}."
end

API REST

API JSON

  1. Ottieni un token di accesso all'autorizzazione da OAuth 2.0 Playground. Configura il parco giochi in modo che utilizzi le tue credenziali OAuth. Per le istruzioni, consulta la pagina relativa all'autenticazione API.
  2. Utilizza cURL per chiamare l'API JSON con una richiesta di bucket GET:

    curl -X GET \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=rpo"

    Dove:

    • OAUTH2_TOKEN è il nome del token di accesso generato nel passaggio 1.
    • BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

    La risposta sarà simile al seguente esempio:

    {
      "name": "my-bucket",
      "projectNumber": "234...",
      ...
      "rpo": "ASYNC_TURBO"
    }

    Nota la chiave rpo. Il valore ASYNC_TURBO indica che la replica turbo è abilitata. DEFAULT indica che viene applicata la replica predefinita. Il campo rpo è sempre presente per i bucket a due e più aree geografiche, ma è assente dai bucket a singola area geografica.

API XML

Questa funzionalità non può essere gestita tramite l'API XML. Usa l'API JSON.

Imposta replica turbo

Per abilitare o disabilitare la replica turbo in un bucket esistente, completa le seguenti istruzioni:

console

  1. In Google Cloud Console, vai alla pagina Browser di Cloud Storage.

    Vai al browser

  2. Nell'elenco dei bucket, fai clic sul nome del bucket desiderato.

  3. Fai clic sulla scheda Configurazione.

  4. Nella riga Replication, fai clic su Modifica.

    La finestra visualizzata indica se stai per abilitare la replica turbo o disattivare la replica turbo.

  5. Fai clic su Salva per confermare la nuova impostazione.

Riga di comando

Utilizza il comando gsutil rpo set:

gsutil rpo set STATE gs://BUCKET_NAME/

Dove:

  • STATE è ASYNC_TURBO per abilitare la replica turbo o DEFAULT per la disattivazione della replica turbo.

  • BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

Se l'operazione ha esito positivo, non viene restituita una risposta. La modifica diventa effettiva immediatamente.

Esempi di codice

C++

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C++.

L'esempio seguente abilita la replica turbo in un bucket:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto updated = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetRpo(gcs::RpoAsyncTurbo()));
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "RPO is set to 'ASYNC_TURBO' for " << updated->name() << "\n";
}

L'esempio seguente abilita la replica predefinita in un bucket:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto updated = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetRpo(gcs::RpoDefault()));
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "RPO is set to 'default' for " << updated->name() << "\n";
}

C#

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C# .

L'esempio seguente abilita la replica turbo in un bucket:

// Copyright 2021 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using System;
using Google.Cloud.Storage.V1;

public class SetRpoAsyncTurboSample
{
    public void SetRpoAsyncTurbo(string bucketName = "your-unique-bucket-name")
    {
        // Enabling turbo replication requires a bucket with dual-region configuration
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.Rpo = "ASYNC_TURBO";
        storage.UpdateBucket(bucket);

        Console.WriteLine($"Turbo replication enabled for bucket {bucketName}");
    }
}

L'esempio seguente abilita la replica predefinita in un bucket:

// Copyright 2021 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using System;
using Google.Cloud.Storage.V1;

public class SetRpoDefaultSample
{
    public void SetRpoDefault(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.Rpo = "DEFAULT";
        storage.UpdateBucket(bucket);

        Console.WriteLine($"Turbo replication disabled for bucket {bucketName}");
    }
}

Go

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Go.

L'esempio seguente abilita la replica turbo in un bucket:

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package buckets

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setRPOAsyncTurbo enables turbo replication for the bucket by setting RPO to
// "ASYNC_TURBO". The bucket must be dual-region to use this feature.
func setRPOAsyncTurbo(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	setRPO := storage.BucketAttrsToUpdate{
		RPO: storage.RPOAsyncTurbo,
	}
	if _, err := bucket.Update(ctx, setRPO); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Turbo replication enabled for %v", bucketName)
	return nil
}

L'esempio seguente abilita la replica predefinita in un bucket:

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package buckets

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setRPODefault disables turbo replication for the bucket by setting RPO to
// "DEFAULT".
func setRPODefault(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	setRPO := storage.BucketAttrsToUpdate{
		RPO: storage.RPODefault,
	}
	if _, err := bucket.Update(ctx, setRPO); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Turbo replication disabled for %v", bucketName)
	return nil
}

Java

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Java.

L'esempio seguente abilita la replica turbo in un bucket:

/*
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.storage.bucket;

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Rpo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetAsyncTurboRpo {
  public static void setAsyncTurboRpo(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);

    bucket.toBuilder().setRpo(Rpo.ASYNC_TURBO).build().update();

    System.out.println("Turbo replication was enabled for " + bucketName);
  }
}

L'esempio seguente abilita la replica predefinita in un bucket:

/*
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.storage.bucket;

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Rpo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetDefaultRpo {
  public static void setDefaultRpo(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);

    bucket.toBuilder().setRpo(Rpo.DEFAULT).build().update();

    System.out.println("Replication was set to default for " + bucketName);
  }
}

Node.js

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

L'esempio seguente abilita la replica turbo in un bucket:

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * This application demonstrates how to perform basic operations on buckets with
 * the Google Cloud Storage API.
 *
 * For more information, see the README.md under /storage and the documentation
 * at https://cloud.google.com/storage/docs.
 */

function main(bucketName = 'my-bucket') {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // The name of your GCS bucket in a dual-region
  // const bucketName = 'Name of a bucket, e.g. my-bucket';

  // Imports the Google Cloud client library
  const {Storage} = require('@google-cloud/storage');

  // Creates a client
  const storage = new Storage();

  // Enable turbo replication for the bucket by setting rpo to ASYNC_TURBO.
  // The bucket must be a dual-region bucket.
  async function setRPOAsyncTurbo() {
    await storage.bucket(bucketName).setMetadata({
      rpo: 'ASYNC_TURBO',
    });

    console.log(`Turbo replication enabled for ${bucketName}.`);
  }

  setRPOAsyncTurbo();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

L'esempio seguente abilita la replica predefinita in un bucket:

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * This application demonstrates how to perform basic operations on buckets with
 * the Google Cloud Storage API.
 *
 * For more information, see the README.md under /storage and the documentation
 * at https://cloud.google.com/storage/docs.
 */

function main(bucketName = 'my-bucket') {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // The name of your GCS bucket in a dual-region
  // const bucketName = 'Name of a bucket, e.g. my-bucket';

  // Imports the Google Cloud client library
  const {Storage} = require('@google-cloud/storage');

  // Creates a client
  const storage = new Storage();

  // Disable turbo replication for the bucket by setting RPO to default.
  // The bucket must be a dual-region bucket.
  async function setRPODefault() {
    await storage.bucket(bucketName).setMetadata({
      rpo: 'DEFAULT',
    });

    console.log(`Turbo replication disabled for ${bucketName}.`);
  }

  setRPODefault();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

PHP

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

L'esempio seguente abilita la replica turbo in un bucket:

<?php
/**
 * Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * For instructions on how to run the full sample:
 *
 * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/master/storage/README.md
 */

namespace Google\Cloud\Samples\Storage;

use Google\Cloud\Storage\StorageClient;

/**
 * Set the bucket's Turbo Replication(rpo) setting to `ASYNC_TURBO`.
 * The bucket must be a dual-region bucket.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function set_rpo_async_turbo($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $rpo = 'ASYNC_TURBO';

    $bucket->update([
        'rpo' => $rpo
    ]);

    printf(
        'The replication behavior or recovery point objective (RPO) has been set to ASYNC_TURBO for %s.' . PHP_EOL,
        $bucketName
    );
}

// The following 2 lines are only needed to run the samples
require_once __DIR__ . '/../../testing/sample_helpers.php';
\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);

L'esempio seguente abilita la replica predefinita in un bucket:

<?php
/**
 * Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * For instructions on how to run the full sample:
 *
 * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/master/storage/README.md
 */

namespace Google\Cloud\Samples\Storage;

use Google\Cloud\Storage\StorageClient;

/**
 * Set the bucket's replication behavior or recovery point objective (RPO) to `DEFAULT`.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function set_rpo_default($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $rpo = 'DEFAULT';

    // Updating the rpo value of a multi-region bucket to DEFAULT has no effect
    // and updating the rpo value of a regional bucket will throw an exception.
    $bucket->update([
        'rpo' => $rpo
    ]);

    printf(
        'The replication behavior or recovery point objective (RPO) has been set to DEFAULT for %s.' . PHP_EOL,
        $bucketName
    );
}

// The following 2 lines are only needed to run the samples
require_once __DIR__ . '/../../testing/sample_helpers.php';
\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);

Python

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Python.

L'esempio seguente abilita la replica turbo in un bucket:

#!/usr/bin/env python

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

"""Sample that sets RPO (Recovery Point Objective) to ASYNC_TURBO
This sample is used on this page:
    https://cloud.google.com/storage/docs/managing-turbo-replication
For more information, see README.md.
"""

from google.cloud import storage
from google.cloud.storage.constants import RPO_ASYNC_TURBO

def set_rpo_async_turbo(bucket_name):
    """Sets the RPO to ASYNC_TURBO, enabling the turbo replication feature"""
    # The ID of your GCS bucket
    # bucket_name = "my-bucket"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    bucket.rpo = RPO_ASYNC_TURBO
    bucket.patch()

    print(f"RPO is set to ASYNC_TURBO for {bucket.name}.")

if __name__ == "__main__":
    set_rpo_async_turbo(bucket_name=sys.argv[1])

L'esempio seguente abilita la replica predefinita in un bucket:

#!/usr/bin/env python

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

"""Sample that sets the replication behavior or recovery point objective (RPO) to default.
This sample is used on this page:
    https://cloud.google.com/storage/docs/managing-turbo-replication
For more information, see README.md.
"""

from google.cloud import storage
from google.cloud.storage.constants import RPO_DEFAULT

def set_rpo_default(bucket_name):
    """Sets the RPO to DEFAULT, disabling the turbo replication feature"""
    # The ID of your GCS bucket
    # bucket_name = "my-bucket"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    bucket.rpo = RPO_DEFAULT
    bucket.patch()

    print(f"RPO is set to DEFAULT for {bucket.name}.")

if __name__ == "__main__":
    set_rpo_default(bucket_name=sys.argv[1])

Ruby

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

L'esempio seguente abilita la replica turbo in un bucket:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

def set_rpo_async_turbo bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name,
                           location: "ASIA"

  bucket.rpo = :ASYNC_TURBO

  puts "Turbo replication is enabled for #{bucket_name}."
end

set_rpo_async_turbo bucket_name: ARGV.shift if $PROGRAM_NAME == __FILE__

L'esempio seguente abilita la replica predefinita in un bucket:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

def set_rpo_default bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name

  bucket.rpo = :DEFAULT

  puts "The replication behavior or recovery point objective (RPO) for #{bucket_name} is set to default."
end

set_rpo_default bucket_name: ARGV.shift if $PROGRAM_NAME == __FILE__

API REST

API JSON

  1. Ottieni un token di accesso all'autorizzazione da OAuth 2.0 Playground. Configura il parco giochi in modo che utilizzi le tue credenziali OAuth. Per le istruzioni, consulta la pagina relativa all'autenticazione API.
  2. Crea un file JSON contenente le seguenti informazioni:

    {
      "rpo": "STATE"
    }

    Dove STATE è ASYNC_TURBO per abilitare Replica turbo o DEFAULT per disabilitare la replica turbo.

  3. Utilizza cURL per chiamare l'API JSON con una richiesta di PATCH bucket:

    curl -X PATCH --data-binary @JSON_FILE_NAME \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=rpo"

    Dove:

    • JSON_FILE_NAME è il percorso del file JSON che hai creato nel passaggio 2.
    • OAUTH2_TOKEN è il token di accesso che hai generato nel passaggio 1.
    • BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

    Se la richiesta ha esito positivo, non viene restituita alcuna risposta.

API XML

Questa funzionalità non può essere gestita tramite l'API XML. Usa l'API JSON.

Crea un bucket a doppia area geografica con replica turbo

Per creare un nuovo bucket a doppia area geografica con replica turbo abilitata, segui le istruzioni riportate di seguito:

console

  1. In Google Cloud Console, vai alla pagina Browser di Cloud Storage.

    Vai al browser

  2. Fai clic su Crea bucket.

  3. Nella pagina Crea un bucket, inserisci le informazioni sul bucket. Per andare al passaggio successivo, fai clic su Continua.

    1. In Assegna un nome al bucket, inserisci un nome che soddisfi i requisiti di denominazione dei bucket.

    2. Per Scegli dove archiviare i dati, accanto a Tipo di località, scegli Doppia area geografica e seleziona la casella di controllo Aggiungi replica turbo.

    3. Per Località, seleziona una delle due aree geografiche disponibili.

    4. Per Scegli una classe di archiviazione predefinita per i tuoi dati, seleziona una classe di archiviazione per il bucket. La classe di archiviazione predefinita viene assegnata per impostazione predefinita a tutti gli oggetti caricati nel bucket.

    5. Per Scegli come controllare l'accesso agli oggetti, seleziona un'opzione Controllo dell'accesso. Il modello di controllo dell'accesso determina il modo in cui controlli l'accesso agli oggetti del bucket.

    6. (Facoltativo) Per le Impostazioni avanzate, aggiungi le etichette di bucket, imposta un criterio di conservazione e scegli un metodo di crittografia.

  4. Fai clic su Crea.

    Per informazioni dettagliate sugli errori nelle operazioni non riuscite nel browser di Cloud Storage, consulta la sezione Risoluzione dei problemi.

Riga di comando

Utilizza il comando gsutil mb --rpo:

gsutil mb -l LOCATION -c CLASS --rpo REPLICATION_TYPE gs://BUCKET_NAME/

Dove:

  • LOCATION specifica la località geografica del bucket. Se non viene specificata alcuna località, il criterio predefinito è US (più aree geografiche). Ai fini di questo esempio, specifica una doppia area geografica. Ad esempio: nam4.

  • CLASS specifica la classe di archiviazione. Ad esempio, NEARLINE.

  • REPLICATION_TYPE specifica l'impostazione di replica per i bucket a due e più aree geografiche. Il valore DEFAULT rappresenta la replica predefinita ed è un'opzione valida per i bucket a due o più aree geografiche. ASYNC_TURBO rappresenta la replica turbo ed è un'opzione valida per molti bucket a doppia area geografica. Se non specificata, la replica predefinita è l'impostazione di replica predefinita. Ai fini di questo esempio, utilizza ASYNC_TURBO.

  • BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

    Se la richiesta ha esito positivo, il comando restituisce il seguente messaggio:

    Creating gs://BUCKET_NAME/...

Esempi di codice

C++

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto bucket =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_rpo(gcs::RpoAsyncTurbo())
                                           .set_location("NAM4"));
  if (!bucket) throw std::runtime_error(bucket.status().message());

  std::cout << "Created bucket " << bucket->name() << " with RPO set to "
            << bucket->rpo() << " in " << bucket->location() << ".\n";
}

C#

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C# .


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateBucketWithTurboReplicationSample
{
    public Bucket CreateBucketWithTurboReplication(
        string projectId = "your-project-id",
        string location = "your-bucket-location",
        string bucketName = "bucket-name")
    {
        var storage = StorageClient.Create();
        // Enabling turbo replication requires a bucket with dual-region configuration
        var bucket = storage.CreateBucket(projectId, new Bucket { Name = bucketName , Location = location, Rpo = "ASYNC_TURBO" });

        Console.WriteLine($"Created {bucket.Name} in {bucket.Location} with RPO Setting {bucket.Rpo}.");
        return bucket;
    }

}

Go

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Go.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// createBucketTurboReplication creates a new dual-region bucket with
// turbo replication enabled.
func createBucketTurboReplication(w io.Writer, projectID, bucketName, location string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	// location := "NAM4" // the name of a dual-region location
	// See this documentation for other valid locations:
	// https://cloud.google.com/storage/docs/locations#location-dr

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	storageLocationAndRPO := &storage.BucketAttrs{
		Location: location,
		RPO:      storage.RPOAsyncTurbo,
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageLocationAndRPO); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v with turbo replication in %v\n", bucketName, storageLocationAndRPO.Location)
	return nil
}

Java

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Java.

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Rpo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithTurboReplication {
  public static void createBucketWithTurboReplication(
      String projectId, String bucketName, String location) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The dual-region location to create your bucket in
    // String location = "NAM4"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setLocation(location)
                .setRpo(Rpo.ASYNC_TURBO)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with RPO setting"
            + bucket.getRpo());
  }
}

Node.js

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a dual-region location
// See this documentation for other valid locations:
// https://cloud.google.com/storage/docs/locations#location-dr
// const location = 'NAM4';

// Flag to enable turbo replication for this bucket
const rpo = 'ASYNC_TURBO';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithTurboReplication() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    rpo,
  });

  console.log(
    `${bucket.name} created with the recovery point objective (RPO) set to ${rpo} in ${location}.`
  );
}

createBucketWithTurboReplication();

PHP

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Create a Cloud Storage bucket with the recovery point objective (RPO) set to `ASYNC_TURBO`.
 * The bucket must be a dual-region bucket for this setting to take effect.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $location The Dual-Region location where you want your bucket to reside (e.g. "US-CENTRAL1+US-WEST1").
                                           Read more at https://cloud.google.com/storage/docs/locations#location-dr
 */
function create_bucket_turbo_replication($bucketName, $location = 'nam4')
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $rpo = 'ASYNC_TURBO';

    // providing a location which is a dual-region location
    // makes sure the locationType is set to 'dual-region' implicitly
    // we can pass 'locationType' => 'dual-region'
    // to make it explicit
    $bucket = $storage->createBucket($bucketName, [
        'location' => $location,
        'rpo' => $rpo
    ]);
    printf('Bucket with recovery point objective (RPO) set to \'ASYNC_TURBO\' created: %s' . PHP_EOL, $bucket->name());
}

Python

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Python.


from google.cloud import storage
from google.cloud.storage.constants import RPO_ASYNC_TURBO

def create_bucket_turbo_replication(bucket_name):
    """Creates dual-region bucket with turbo replication enabled."""
    # The ID of your GCS bucket
    # bucket_name = "my-bucket"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    bucket.location = "NAM4"
    bucket.rpo = RPO_ASYNC_TURBO
    bucket.create()

    print(f"{bucket.name} created with the recovery point objective (RPO) set to {bucket.rpo} in {bucket.location}.")

Ruby

Per maggiori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

def create_bucket_turbo_replication bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location: "ASIA1",
                                  rpo:      "ASYNC_TURBO"

  puts "Created bucket #{bucket.name} in #{bucket.location} with "
  + "the recovery point objective (RPO) set to #{bucket.rpo}."
end

API REST

API JSON

  1. Ottieni un token di accesso all'autorizzazione da OAuth 2.0 Playground. Configura il parco giochi in modo che utilizzi le tue credenziali OAuth. Per le istruzioni, consulta la pagina relativa all'autenticazione API.
  2. Crea un file JSON contenente le impostazioni del bucket, che devono includere un name per il bucket. Consulta la documentazione Bucket:Inserisci per un elenco completo delle impostazioni. Di seguito sono riportate le impostazioni comuni da includere:

    {
      "name": "BUCKET_NAME",
      "rpo": "REPLICATION_TYPE",
      "location": "BUCKET_LOCATION",
      "storageClass": "STORAGE_CLASS",
      "iamConfiguration": {
        "uniformBucketLevelAccess": {
          "enabled": true
        },
      }
    }

    Dove:

    • BUCKET_NAME è il nome che vuoi assegnare al tuo bucket, soggetto ai requisiti di denominazione. Ad esempio, my-bucket.
    • REPLICATION_TYPE specifica l'impostazione di replica per i bucket a due e più aree geografiche. Il valore DEFAULT rappresenta la replica predefinita ed è un'opzione valida per bucket a doppia area geografica o a più aree geografiche. ASYNC_TURBO rappresenta la replica turbo ed è un'opzione valida per la maggior parte dei bucket a doppia area geografica. Se non specificata, la replica predefinita è l'impostazione di replica predefinita. Ai fini di questo esempio, utilizza ASYNC_TURBO.
    • BUCKET_LOCATION è la località in cui vuoi archiviare i dati degli oggetti del tuo bucket. Poiché stai creando un bucket con la replica turbo attivata e poiché la località geografica di un bucket è immutabile, una volta vengono specificate le due aree geografiche. Ad esempio: NAM4.
    • STORAGE_CLASS è la classe di archiviazione predefinita del bucket. Ad esempio: NEARLINE.
  3. Utilizza cURL per chiamare l'API JSON:

    curl -X POST --data-binary @JSON_FILE_NAME \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b?project=PROJECT_ID"

    Dove:

    • JSON_FILE_NAME è il percorso del file JSON che hai creato nel passaggio 2.
    • OAUTH2_TOKEN è il token di accesso che hai generato nel passaggio 1.
    • PROJECT_ID è l'ID del progetto a cui verrà associato il bucket. Ad esempio, my-project.

API XML

Questa funzionalità non può essere gestita tramite l'API XML. Usa l'API JSON.

Monitorare le prestazioni della replica turbo di un bucket

  1. In Google Cloud Console, vai alla pagina Browser di Cloud Storage.

    Vai al browser

  2. Nell'elenco dei bucket, fai clic sul nome del bucket desiderato.

  3. Fai clic sulla scheda Configurazione.

  4. Nella riga Replica, fai clic su Visualizza metriche di replica.

    Se la replica di un oggetto ha richiesto più di 15 minuti, i minuti aggiuntivi vengono aggregati e visualizzati in Google Cloud Console come Numero di minuti non conformi all'RPO. Google Cloud Console monitora inoltre il numero di repliche degli oggetti completate, mostrate come Repliche di oggetti con turbo.

    Per saperne di più, consulta Informazioni su RTO e RPO.

Passaggi successivi