Usa claves de encriptación administradas por el cliente

Ir a los conceptos

En esta página, se describe cómo usar una clave de encriptación de Cloud Key Management Service con Cloud Storage, lo que incluye la configuración de claves predeterminadas en los depósitos y la adición de claves a objetos individuales. La clave de encriptación de Cloud KMS es una clave de encriptación administrada por el cliente que crea Cloud KMS y la administras tú.

Para obtener más información general sobre Cloud KMS, consulta Cloud KMS.

Requisitos previos

Antes de usar esta función en Cloud Storage, debes realizar las siguientes acciones:

1. Habilita la API de Cloud KMS del proyecto que almacenará tus claves de encriptación.

   Habilitar la API

2. Ten el permiso suficiente en el proyecto que almacenará tus claves de encriptación:

   • Si eres propietario del proyecto que almacenará tus claves, lo más probable es que tengas el permiso necesario.

   • Si planeas crear claves y llaveros de claves de encriptación nuevos, debes tener los permisos cloudkms.keyRings.create y cloudkms.cryptoKey.create.

   • Ya sea que planees usar claves o llaveros de claves nuevos o existentes, debes tener el permiso cloudkms.cryptoKey.setIamPolicy para las claves que usarás en la encriptación.

     Este permiso te permite otorgar a las cuentas de servicio de Cloud Storage acceso a las claves de Cloud KMS.

   • Los permisos anteriores se encuentran en la función de administrador de Cloud KMS.

     Consulta Usa IAM con Cloud KMS para más instrucciones sobre cómo obtener estas o algunas otras funciones de Cloud KMS.

3. Ten permiso suficiente para trabajar con objetos en tu bucket de Cloud Storage:

   • Si eres propietario del proyecto que contiene el bucket, es probable que tengas el permiso necesario.

   • Si usas IAM, deberías tener el permiso storage.objects.create para escribir objetos en el bucket y storage.objects.get a fin de leer objetos del bucket. Consulta la sección sobre cómo usar permisos de IAM si quieres ver las instrucciones para obtener una función, como Administrador de objetos de almacenamiento, que tenga estos permisos.

   • Si usas LCA, deberías tener un permiso WRITER para buckets a fin de escribir objetos en el bucket y un permiso READER para objetos a fin de leer objetos del bucket. Consulta la configuración de las LCA y obtén instrucciones para realizar esto.

4. Obtén un llavero de claves de Cloud KMS y al menos una clave dentro de este.

   Nota: Debes crear la clave de Cloud KMS en la misma ubicación que los datos que deseas encriptar. Para conocer las ubicaciones de Cloud KMS disponibles, consulta las ubicaciones de Cloud KMS.
5. Nota: El siguiente paso no es necesario si usas la herramienta de gsutil.

   Obtén la dirección de correo electrónico de la cuenta de servicio asociada con el proyecto que contiene tu depósito de Cloud Storage.

Asigna una clave de Cloud KMS a una cuenta de servicio

Para usar las claves de encriptación administradas por el cliente, otorga permiso a tu cuenta de servicio de Cloud Storage para usar tu clave de Cloud KMS:

Console

1. Abre el navegador de claves de Cloud Key Management Service en Google Cloud Console.
   Abrir el navegador de claves de Cloud KMS

2. Haz clic en el nombre del llavero de claves que contiene la clave que desees.

3. Selecciona la casilla de verificación de la clave que deseas.

   La pestaña de Permisos en el panel de la ventana derecha estará disponible.

4. En el cuadro de diálogo Agregar miembros, especifica la dirección de correo electrónico de la cuenta de servicio de Cloud Storage a la que vas a otorgar acceso.

5. En el menú desplegable Seleccionar una función, selecciona Encriptador y desencriptador de CryptoKey de Cloud KMS.

6. Haz clic en Agregar.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil kms authorize a fin de otorgarle a la cuenta de servicio asociada con tu bucket el permiso para encriptar y desencriptar objetos con tu clave de Cloud KMS:

gsutil kms authorize -p PROJECT_STORING_OBJECTS -k KEY_RESOURCE

Donde:

• PROJECT_STORING_OBJECTS es el ID del proyecto que contiene los objetos que deseas encriptar o desencriptar. Por ejemplo, my-pet-project.
• KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

Si deseas quitar el permiso otorgado, debes usar la herramienta de línea de comandos de gcloud o Google Cloud Console.

Muestras de código

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

Ver en GitHub Comentarios

using Google.Cloud.Iam.V1;
using Google.Cloud.Kms.V1;

public class IamAddMemberSample
{
    public Policy IamAddMember(
      string projectId = "my-project", string locationId = "us-east1", string keyRingId = "my-key-ring", string keyId = "my-key",
      string member = "user:[e-mail]")
    {
        // Create the client.
        KeyManagementServiceClient client = KeyManagementServiceClient.Create();

        // Build the resource name.
        CryptoKeyName resourceName = new CryptoKeyName(projectId, locationId, keyRingId, keyId);

        // The resource name could also be a key ring.
        // var resourceName = new KeyRingName(projectId, locationId, keyRingId);

        // Get the current IAM policy.
        Policy policy = client.GetIamPolicy(resourceName);

        // Add the member to the policy.
        policy.AddRoleMember("roles/cloudkms.cryptoKeyEncrypterDecrypter", member);

        // Save the updated IAM policy.
        Policy result = client.SetIamPolicy(resourceName, policy);

        // Return the resulting policy.
        return result;
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
)

// iamAddMember adds a new IAM member to the Cloud KMS key
func iamAddMember(w io.Writer, name, member string) error {
	// NOTE: The resource name can be either a key or a key ring. If IAM
	// permissions are granted on the key ring, the permissions apply to all keys
	// in the key ring.
	//
	// name := "projects/my-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key"
	// member := "user:[e-mail]"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %v", err)
	}

	// Get the current IAM policy.
	handle := client.ResourceIAM(name)
	policy, err := handle.Policy(ctx)
	if err != nil {
		return fmt.Errorf("failed to get IAM policy: %v", err)
	}

	// Grant the member permissions. This example grants permission to use the key
	// to encrypt data.
	policy.Add(member, "roles/cloudkms.cryptoKeyEncrypterDecrypter")
	if err := handle.SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("failed to save policy: %v", err)
	}

	fmt.Fprintf(w, "Updated IAM policy for %s\n", name)
	return nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

Ver en GitHub Comentarios

import com.google.cloud.kms.v1.CryptoKeyName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.iam.v1.Binding;
import com.google.iam.v1.Policy;
import java.io.IOException;

public class IamAddMember {

  public void iamAddMember() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String keyId = "my-key";
    String member = "user:[e-mail]";
    iamAddMember(projectId, locationId, keyRingId, keyId, member);
  }

  // Add the given IAM member to the key.
  public void iamAddMember(
      String projectId, String locationId, String keyRingId, String keyId, String member)
      throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the key version name from the project, location, key ring, key,
      // and key version.
      CryptoKeyName resourceName = CryptoKeyName.of(projectId, locationId, keyRingId, keyId);

      // The resource name could also be a key ring.
      // KeyRingName resourceName = KeyRingName.of(projectId, locationId, keyRingId);

      // Get the current policy.
      Policy policy = client.getIamPolicy(resourceName);

      // Create a new IAM binding for the member and role.
      Binding binding =
          Binding.newBuilder()
              .setRole("roles/cloudkms.cryptoKeyEncrypterDecrypter")
              .addMembers(member)
              .build();

      // Add the binding to the policy.
      Policy newPolicy = policy.toBuilder().addBindings(binding).build();

      client.setIamPolicy(resourceName, newPolicy);
      System.out.printf("Updated IAM policy for %s%n", resourceName.toString());
    }
  }
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

Ver en GitHub Comentarios

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const keyId = 'my-key';
// const member = 'user:[e-mail]';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the resource name
const resourceName = client.cryptoKeyPath(
  projectId,
  locationId,
  keyRingId,
  keyId
);

// The resource name could also be a key ring.
// const resourceName = client.keyRingPath(projectId, locationId, keyRingId);

async function iamAddMember() {
  // Get the current IAM policy.
  const [policy] = await client.getIamPolicy({
    resource: resourceName,
  });

  // Add the member to the policy.
  policy.bindings.push({
    role: 'roles/cloudkms.cryptoKeyEncrypterDecrypter',
    members: [member],
  });

  // Save the updated policy.
  const [updatedPolicy] = await client.setIamPolicy({
    resource: resourceName,
    policy: policy,
  });

  console.log('Updated policy');
  return updatedPolicy;
}

return iamAddMember();

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

Ver en GitHub Comentarios

use Google\Cloud\Iam\V1\Binding;
use Google\Cloud\Kms\V1\KeyManagementServiceClient;

function iam_add_member_sample(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $member = 'user:[e-mail]'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the resource name.
    $resourceName = $client->cryptoKeyName($projectId, $locationId, $keyRingId, $keyId);

    // The resource name could also be a key ring.
    // $resourceName = $client->keyRingName($projectId, $locationId, $keyRingId);

    // Get the current IAM policy.
    $policy = $client->getIamPolicy($resourceName);

    // Add the member to the policy.
    $bindings = $policy->getBindings();
    $bindings[] = (new Binding())
        ->setRole('roles/cloudkms.cryptoKeyEncrypterDecrypter')
        ->setMembers([$member]);
    $policy->setBindings($bindings);

    // Save the updated IAM policy.
    $updatedPolicy = $client->setIamPolicy($resourceName, $policy);
    printf('Added %s' . PHP_EOL, $member);
    return $updatedPolicy;
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

Ver en GitHub Comentarios

def iam_add_member(project_id, location_id, key_ring_id, key_id, member):
    """
    Add an IAM member to a resource.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        key_id (string): ID of the key to use (e.g. 'my-key').
        member (string): Member to add (e.g. 'user:[e-mail]')

    Returns:
        Policy: Updated Cloud IAM policy.

    """

    # Import the client library.
    from google.cloud import kms

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Build the resource name.
    resource_name = client.crypto_key_path(project_id, location_id, key_ring_id, key_id)

    # The resource name could also be a key ring.
    # resource_name = client.key_ring_path(project_id, location_id, key_ring_id);

    # Get the current policy.
    policy = client.get_iam_policy(request={'resource': resource_name})

    # Add the member to the policy.
    policy.bindings.add(
        role='roles/cloudkms.cryptoKeyEncrypterDecrypter',
        members=[member])

    # Save the updated IAM policy.
    request = {
        'resource': resource_name,
        'policy': policy
    }

    updated_policy = client.set_iam_policy(request=request)
    print('Added {} to {}'.format(member, resource_name))
    return updated_policy

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

Ver en GitHub Comentarios

# TODO(developer): uncomment these values before running the sample.
# project_id  = "my-project"
# location_id = "us-east1"
# key_ring_id = "my-key-ring"
# key_id      = "my-key"
# member      = "user:[e-mail]"

# Require the library.
require "google/cloud/kms"

# Create the client.
client = Google::Cloud::Kms.key_management_service

# Build the resource name.
resource_name = client.crypto_key_path project:    project_id,
                                       location:   location_id,
                                       key_ring:   key_ring_id,
                                       crypto_key: key_id

# The resource name could also be a key ring.
# resource_name = client.key_ring_path project: project_id, location: location_id, key_ring: key_ring_id

# Create the IAM client.
iam_client = Google::Cloud::Kms::V1::IAMPolicy::Client.new

# Get the current IAM policy.
policy = iam_client.get_iam_policy resource: resource_name

# Add the member to the policy.
policy.bindings << Google::Iam::V1::Binding.new(
  members: [member],
  role:    "roles/cloudkms.cryptoKeyEncrypterDecrypter"
)

# Save the updated policy.
updated_policy = iam_client.set_iam_policy resource: resource_name, policy: policy
puts "Added #{member}"

API de REST

API de JSON

Nota: Esta tarea usa un extremo separado en comparación con la mayoría de las tareas de Cloud Storage.

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .json que contenga la siguiente información:

   {
     "policy": {
       "bindings": {
         "role": "roles/cloudkms.cryptoKeyEncrypterDecrypter",
         "members": "SERVICE_ACCOUNT_EMAIL_ADDRESS"
       },
     }
   }

   En el ejemplo anterior, SERVICE_ACCOUNT_EMAIL_ADDRESS es la dirección de correo electrónico asociada a tu cuenta de servicio. Por ejemplo, [e-mail].

3. Usa cURL para llamar a la API de Cloud KMS con una solicitud POST setIamPolicy:

   curl -X POST --data-binary @JSON_FILE_NAME.json \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   -H "Content-Type: application/json" \
   "https://cloudkms.googleapis.com/v1/KEY_RESOURCE:setIamPolicy"

   Donde:

   • JSON_FILE_NAME es el nombre del archivo que creaste en el paso 2.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

Precaución: Esta solicitud reemplaza cualquier política de IAM existente en el recurso de clave.

Nota: Puede haber una demora de varios segundos entre la asignación de la función y su aplicación a tu cuenta de servicio. Si otorgas este permiso de manera programática, espera 30 segundos antes de configurar Cloud Storage.

API de XML

La API de XML no se puede usar para asignar Cloud KMS a una cuenta de servicio. Usa una de las otras herramientas de Cloud Storage, como gsutil, en su lugar.

Usa las claves de encriptación predeterminadas

Agrega o cambia las claves predeterminadas de un bucket

Sigue los pasos a continuación para agregar o cambiar la clave de Cloud KMS que se usa de forma predeterminada cuando los objetos se escriben en un bucket:

Console

1. Abre el navegador de Cloud Storage en Google Cloud Console.
   Abrir el navegador de Cloud Storage

2. En la lista de bucket s, haz clic en el bucket que desees.

3. En la página de detalles del bucket, haz clic en la pestaña Configuración.

4. Haz clic en el ícono de lápiz asociado a la entrada Tipo de encriptación.

5. Si el bucket no usa actualmente una clave de Cloud KMS, selecciona el botón de selección Clave administrada por el cliente.

6. En el menú desplegable asociado con las claves administradas por el cliente, selecciona una de las claves disponibles.

7. Haz clic en Guardar.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption -k KEY_RESOURCE gs://BUCKET_NAME

Donde:

• KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.
• BUCKET_NAME es el nombre del bucket correspondiente. Por ejemplo, my-bucket.

Si se ejecuta de forma correcta, la respuesta se ve de la siguiente manera:

Setting default KMS key for bucket gs://my-bucket...

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

Ver en GitHub Comentarios

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& key_name) {
  StatusOr<gcs::BucketMetadata> updated = client.PatchBucket(
      bucket_name, gcs::BucketMetadataPatchBuilder().SetEncryption(
                       gcs::BucketEncryption{key_name}));
  if (!updated) throw std::runtime_error(updated.status().message());

  if (!updated->has_encryption()) {
    std::cerr << "The change to set the encryption attribute on bucket "
              << updated->name()
              << " was sucessful, but the encryption is not set."
              << "This is unexpected, maybe a concurrent change?\n";
    return;
  }

  std::cout << "Successfully set default KMS key on bucket "
            << updated->name() << " to "
            << updated->encryption().default_kms_key_name << "."
            << "\nFull metadata: " << *updated << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

Ver en GitHub Comentarios

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

public class EnableDefaultKMSKeySample
{
    public Bucket EnableDefaultKMSKey(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string keyLocation = "us-west1",
        string kmsKeyRing = "kms-key-ring",
        string kmsKeyName = "key-name")
    {
        // KMS Key identifier of an already created KMS key.
        // If you use the Google.Cloud.Kms.V1 library, you can construct these names using helper class CryptoKeyName.
        // var fullKeyName = new CryptoKeyName(projectId, keyLocation, kmsKeyRing, kmsKeyName).ToString();
        string keyPrefix = $"projects/{projectId}/locations/{keyLocation}";
        string fullKeyringName = $"{keyPrefix}/keyRings/{kmsKeyRing}";
        string fullKeyName = $"{fullKeyringName}/cryptoKeys/{kmsKeyName}";
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        bucket.Encryption = new Bucket.EncryptionData { DefaultKmsKeyName = fullKeyName };
        var updatedBucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Default KMS key for {bucketName} was set to {kmsKeyName}.");
        return updatedBucket;
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

Ver en GitHub Comentarios

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

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

// setBucketDefaultKMSKey sets the Cloud KMS encryption key for the bucket.
func setBucketDefaultKMSKey(w io.Writer, bucketName, keyName string) error {
	// bucketName := "bucket-name"
	// keyName := "key"
	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)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Encryption: &storage.BucketEncryption{DefaultKMSKeyName: keyName},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Default KMS Key Name: %v", bucketAttrsToUpdate.Encryption.DefaultKMSKeyName)
	return nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

Ver en GitHub Comentarios

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of the existing bucket to set a default KMS key for, e.g. "my-bucket"
// String bucketName = "my-bucket"

// The name of the KMS-key to use as a default
// Key names are provided in the following format:
// 'projects/<PROJECT>/locations/<LOCATION>/keyRings/<RING_NAME>/cryptoKeys/<KEY_NAME>'
// String kmsKeyName = ""

BucketInfo bucketInfo =
    BucketInfo.newBuilder(bucketName).setDefaultKmsKeyName(kmsKeyName).build();

Bucket bucket = storage.update(bucketInfo);

System.out.println("Default KMS Key Name: " + bucket.getDefaultKmsKeyName());

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

Ver en GitHub Comentarios

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const defaultKmsKeyName = 'KMS key resource id, e.g. my-key';

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

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

async function enableDefaultKMSKey() {
  await storage.bucket(bucketName).setMetadata({
    encryption: {
      defaultKmsKeyName,
    },
  });

  console.log(
    `Default KMS key for ${bucketName} was set to ${defaultKmsKeyName}.`
  );
}

enableDefaultKMSKey().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

Ver en GitHub Comentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Enable a bucket's requesterpays metadata.
 *
 * @param string $projectId Your Google Cloud project ID.
 * @param string $bucketName Name of your Google Cloud Storage bucket.
 * @param string $kmsKeyName KMS key ID to use as the default KMS key.
 *
 * @return void
 */
function enable_default_kms_key($projectId, $bucketName, $kmsKeyName)
{
    $storage = new StorageClient([
        'projectId' => $projectId
    ]);
    $bucket = $storage->bucket($bucketName);
    $bucket->update([
        'encryption' => [
            'defaultKmsKeyName' => $kmsKeyName
        ]
    ]);
    printf('Default KMS key for %s was set to %s' . PHP_EOL,
        $bucketName,
        $bucket->info()['encryption']['defaultKmsKeyName']);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

Ver en GitHub Comentarios

from google.cloud import storage

def enable_default_kms_key(bucket_name, kms_key_name):
    """Sets a bucket's default KMS key."""
    # bucket_name = "your-bucket-name"
    # kms_key_name = "projects/PROJ/locations/LOC/keyRings/RING/cryptoKey/KEY"

    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    bucket.default_kms_key_name = kms_key_name
    bucket.patch()

    print(
        "Set default KMS key for bucket {} to {}.".format(
            bucket.name, bucket.default_kms_key_name
        )
    )

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

Ver en GitHub Comentarios

def set_bucket_default_kms_key bucket_name:, default_kms_key:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The name of the KMS key to manage this object with
  # default_kms_key = "projects/your-project-id/locations/global/keyRings/your-key-ring/cryptoKeys/your-key"

  require "google/cloud/storage"

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

  bucket.default_kms_key = default_kms_key

  puts "Default KMS key for #{bucket.name} was set to #{bucket.default_kms_key}"
end

API de REST

API de JSON

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .json que contenga la siguiente información:

   {
     "encryption": {
       "defaultKmsKeyName": "KEY_RESOURCE"
     }
   }

   En el ejemplo anterior, KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

3. Usa cURL para llamar a la API de JSON con una solicitud de bucket PATCH:

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

   Donde:

   • JSON_FILE_NAME es el archivo que creaste en el paso 2.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

API de XML

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .xml que contenga la siguiente información:

   <EncryptionConfiguration>
     <DefaultKmsKeyName>KEY_RESOURCE</DefaultKmsKeyName>
   </EncryptionConfiguration>

   En el ejemplo anterior, KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

3. Usa cURL para llamar a la API de XML con una solicitud de bucket PUT y un parámetro de string de consulta encryption:

   curl -X PUT --data-binary @XML_FILE_NAME.xml \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/BUCKET_NAME?encryptionConfig"

   Donde:

   • XML_FILE_NAME es el archivo que creaste en el paso 2.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

Nota: Los objetos que se escribieron en un bucket antes de agregar o cambiar la clave predeterminada permanecen encriptados con el método de encriptación anterior.

Ve la clave predeterminada de un bucket

Sigue los pasos a continuación para ver la clave de Cloud KMS que actualmente está configurada como predeterminada en tu bucket:

Console

1. Abre el navegador de Cloud Storage en Google Cloud Console.
   Abrir el navegador de Cloud Storage

2. En la lista de bucket s, haz clic en el bucket que desees.

3. En la página de detalles del bucket, haz clic en la pestaña Configuración.

4. La clave predeterminada actual de tu bucket aparece en el campo Clave de encriptación.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption gs://BUCKET_NAME

En el ejemplo anterior, BUCKET_NAME es el nombre del bucket cuya clave deseas ver. Por ejemplo, my-bucket.

Si tiene éxito, la respuesta se ve de la manera siguiente:

Default encryption key for gs://my-bucket:
KEY_RESOURCE

API de REST

API de JSON

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Usa cURL para llamar a la API de JSON con una solicitud de bucket GET que incluya los fields deseados:

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

   Donde:

   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del bucket cuya clave deseas ver. Por ejemplo, my-bucket.

   La respuesta se ve como el siguiente ejemplo:

   {
     "encryption" : {
        "defaultKmsKeyName": "KEY_RESOURCE"
      },
   }

API de XML

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Usa cURL para llamar a la API de XML con una solicitud de bucket GET que incluya el parámetro de consulta encryption:

   curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/BUCKET_NAME?encryptionConfig"

   Donde:

   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del bucket cuya clave deseas ver. Por ejemplo, my-bucket.

   La respuesta se ve como el siguiente ejemplo:

   <EncryptionConfiguration>
     <DefaultKmsKeyName>KEY_RESOURCE</DefaultKmsKeyName>
   </EncryptionConfiguration>

Quita la clave predeterminada de un bucket

Sigue los pasos a continuación para quitar cualquier conjunto de claves de Cloud KMS predeterminadas en un bucket:

Console

1. Abre el navegador de Cloud Storage en Google Cloud Console.
   Abrir el navegador de Cloud Storage

2. En la lista de bucket s, haz clic en el bucket que desees.

3. En la página de detalles del bucket, haz clic en la pestaña Configuración.

4. Haz clic en el ícono de lápiz asociado a la entrada Tipo de encriptación.

5. Selecciona el botón de selección Clave administrada por Google.

6. Haz clic en Guardar.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption -d gs://BUCKET_NAME

En el ejemplo anterior, BUCKET_NAME es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

Si se ejecuta de forma correcta, la respuesta se ve de la siguiente manera:

Clearing default encryption key for gs://my-bucket...

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

Ver en GitHub Comentarios

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

  std::cout << "Successfully removed default KMS key on bucket "
            << updated->name() << "\n";
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

Ver en GitHub Comentarios

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

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

// removeBucketDefaultKMSKey removes any default Cloud KMS key set on a bucket.
func removeBucketDefaultKMSKey(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)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Encryption: &storage.BucketEncryption{},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Default KMS key was removed from: %v", bucketName)
	return nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

Ver en GitHub Comentarios

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

public class RemoveBucketDefaultKMSKey {
  public static void removeBucketDefaultKmsKey(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().setDefaultKmsKeyName(null).build().update();

    System.out.println("Default KMS key was removed from " + bucketName);
  }
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

Ver en GitHub Comentarios

from google.cloud import storage

def bucket_delete_default_kms_key(bucket_name):
    """Delete a default KMS key of bucket"""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.default_kms_key_name = None
    bucket.patch()

    print("Default KMS key was removed from {}".format(bucket.name))
    return bucket

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

Ver en GitHub Comentarios

def bucket_delete_default_kms_key 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.default_kms_key = nil

  puts "Default KMS key was removed from #{bucket_name}"
end

API de REST

API de JSON

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .json que contenga la siguiente información:

   {
     "encryption": {
       "defaultKmsKeyName": null
     }
   }

3. Usa cURL para llamar a la API de JSON con una solicitud de bucket PATCH:

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

   Donde:

   • JSON_FILE_NAME es el archivo que creaste en el paso 2.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

API de XML

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .xml que contenga la siguiente información:

   <EncryptionConfiguration></EncryptionConfiguration>

3. Usa cURL para llamar a la API de XML con una solicitud de bucket PUT y un parámetro de string de consulta encryption:

   curl -X PUT --data-binary @XML_FILE_NAME.xml \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/BUCKET_NAME?encryptionConfig"

   Donde:

   • XML_FILE_NAME es el archivo que creaste en el paso 2.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

Nota: Los objetos que se escribieron en un bucket antes de quitar la clave predeterminada y que usaron esta clave permanecen encriptados con ella.

Encripta un objeto con una clave de Cloud KMS

Puedes encriptar un objeto individual con una clave de Cloud KMS. Esto es útil si deseas usar una clave diferente a la clave predeterminada establecida en el bucket o si no tienes una clave predeterminada establecida en el bucket.

Console

Cloud Console no se puede usar para encriptar objetos individuales. Usa gsutil o las bibliotecas cliente en su lugar.

gsutil

1. Agrega la siguiente opción a la sección [GSUtil] de tu archivo de configuración .boto:

   encryption_key = KEY_RESOURCE

   En el ejemplo anterior, KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

   Nota: Como alternativa, puedes incluir esta información en cada comando de gsutil con la marca de nivel superior -o: -o "GSUtil:encryption_key=KEY_RESOURCE".

2. Escribe un objeto en el bucket como lo harías siempre, por ejemplo, con gsutil cp o gsutil rewrite.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

Ver en GitHub Comentarios

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, std::string const& old_csek_key_base64,
   std::string const& new_cmek_key_name) {
  StatusOr<gcs::ObjectMetadata> metadata = client.RewriteObjectBlocking(
      bucket_name, object_name, bucket_name, object_name,
      gcs::SourceEncryptionKey::FromBase64Key(old_csek_key_base64),
      gcs::DestinationKmsKeyName(new_cmek_key_name));
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "Changed object " << metadata->name() << " in bucket "
            << metadata->bucket()
            << " from using CSEK to CMEK key.\nFull Metadata: " << *metadata
            << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

Ver en GitHub Comentarios

        private void UploadEncryptedFileWithKmsKey(string bucketName,
            string keyLocation, string kmsKeyRing, string kmsKeyName,
            string localPath, string objectName = null)
        {
            string KeyPrefix = $"projects/{s_projectId}/locations/{keyLocation}";
            string FullKeyringName = $"{KeyPrefix}/keyRings/{kmsKeyRing}";
            string FullKeyName = $"{FullKeyringName}/cryptoKeys/{kmsKeyName}";

            var storage = StorageClient.Create();
            using (var f = File.OpenRead(localPath))
            {
                objectName = objectName ?? Path.GetFileName(localPath);
                storage.UploadObject(bucketName, objectName, null, f,
                    new UploadObjectOptions()
                    {
                        KmsKeyName = FullKeyName
                    });
                Console.WriteLine($"Uploaded {objectName}.");
            }
        }

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

Ver en GitHub Comentarios

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

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

// uploadWithKMSKey writes an object using Cloud KMS encryption.
func uploadWithKMSKey(w io.Writer, bucket, object, keyName string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	// keyName := "projects/projectId/locations/global/keyRings/keyRingID/cryptoKeys/cryptoKeyID"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	obj := client.Bucket(bucket).Object(object)

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

	// Encrypt the object's contents.
	wc := obj.NewWriter(ctx)
	wc.KMSKeyName = keyName
	if _, err := wc.Write([]byte("top secret")); err != nil {
		return fmt.Errorf("Writer.Write: %v", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Uploaded blob %v with KMS key.\n", object)
	return nil
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

Ver en GitHub Comentarios

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';
// const kmsKeyName = 'KMS key resource id, e.g. my-key';

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

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

async function uploadFileWithKmsKey() {
  // Uploads a local file to the bucket with the kms key
  await storage.bucket(bucketName).upload(filename, {
    kmsKeyName,
  });

  console.log(`${filename} uploaded to ${bucketName} using ${kmsKeyName}.`);
}

uploadFileWithKmsKey().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

Ver en GitHub Comentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file using KMS encryption.
 *
 * @param string $projectId Your Google Cloud project ID.
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 * @param string $kmsKeyName KMS key ID used to encrypt objects server side.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_with_kms_key($projectId, $bucketName, $objectName, $source, $kmsKeyName)
{
    $storage = new StorageClient([
        'projectId' => $projectId,
    ]);
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName,
        'destinationKmsKeyName' => $kmsKeyName,
    ]);
    printf('Uploaded %s to gs://%s/%s using encryption key %s' . PHP_EOL,
        basename($source),
        $bucketName,
        $objectName,
        $kmsKeyName);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

Ver en GitHub Comentarios

from google.cloud import storage

def object_csek_to_cmek(bucket_name, blob_name, encryption_key, kms_key_name):
    """Change a blob's customer-supplied encryption key to KMS key"""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # encryption_key = "TIbv/fjexq+VmtXzAlc63J4z5kFmWJ6NdAPQulQBT7g="
    # kms_key_name = "projects/PROJ/locations/LOC/keyRings/RING/cryptoKey/KEY"

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

    current_encryption_key = base64.b64decode(encryption_key)
    source_blob = bucket.blob(blob_name, encryption_key=current_encryption_key)

    destination_blob = bucket.blob(blob_name, kms_key_name=kms_key_name)
    token, rewritten, total = destination_blob.rewrite(source_blob)

    while token is not None:
        token, rewritten, total = destination_blob.rewrite(source_blob, token=token)

    print(
        "Blob {} in bucket {} is now managed by the KMS key {} instead of a customer-supplied encryption key".format(
            blob_name, bucket_name, kms_key_name
        )
    )
    return destination_blob

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

Ver en GitHub Comentarios

def upload_with_kms_key bucket_name:, local_file_path:, file_name: nil, kms_key:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  # The name of the KMS key to manage this object with
  # kms_key = "projects/your-project-id/locations/global/keyRings/your-key-ring/cryptoKeys/your-key"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  bucket = storage.bucket bucket_name

  file = bucket.create_file local_file_path, file_name, kms_key: kms_key

  puts "Uploaded #{file.name} and encrypted service side using #{file.kms_key}"
end

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

En el siguiente ejemplo, se encripta un objeto con una clave de encriptación administrada por el cliente:

Ver en GitHub Comentarios

byte[] data = "Hello, World!".getBytes(UTF_8);

// The name of the existing bucket to set a default KMS key for, e.g. "my-bucket"
// String bucketName = "my-bucket"

// The name of the KMS-key to use as a default
// Key names are provided in the following format:
// 'projects/<PROJECT>/locations/<LOCATION>/keyRings/<RING_NAME>/cryptoKeys/<KEY_NAME>'
// String kmsKeyName = ""

BlobId blobId = BlobId.of(bucketName, blobName);
BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
Blob blob = storage.create(blobInfo, data, BlobTargetOption.kmsKeyName(kmsKeyName));

En el siguiente ejemplo, se cambia la clave que se usa para encriptar un objeto de una clave de encriptación proporcionada por el cliente a una clave de encriptación administrada por el cliente:

Ver en GitHub Comentarios

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

public class ChangeObjectCSEKtoKMS {
  public static void changeObjectFromCSEKtoKMS(
      String projectId,
      String bucketName,
      String objectName,
      String decryptionKey,
      String kmsKeyName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

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

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The Base64 encoded decryption key, which should be the same key originally used to encrypt
    // the object
    // String decryptionKey = "TIbv/fjexq+VmtXzAlc63J4z5kFmWJ6NdAPQulQBT7g=";

    // The name of the KMS key to manage this object with
    // String kmsKeyName =
    // "projects/your-project-id/locations/global/keyRings/your-key-ring/cryptoKeys/your-key";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    Storage.CopyRequest request =
        Storage.CopyRequest.newBuilder()
            .setSource(blobId)
            .setSourceOptions(Storage.BlobSourceOption.decryptionKey(decryptionKey))
            .setTarget(blobId, Storage.BlobTargetOption.kmsKeyName(kmsKeyName))
            .build();
    storage.copy(request);

    System.out.println(
        "Object "
            + objectName
            + " in bucket "
            + bucketName
            + " is now managed by the KMS key "
            + kmsKeyName
            + " instead of a customer-supplied encryption key");
  }
}

API de REST

API de JSON

Nota: Estos pasos se aplican en específico a la inserción de objetos mediante la API de JSON. Puedes seguir un procedimiento similar para redactar o volver a escribir objetos con la API de JSON.

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.

2. Agrega los datos del objeto al cuerpo de la solicitud.

3. Usa cURL para llamar a la API de JSON con una solicitud de objeto POST:

   curl -X POST --data-binary @OBJECT \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   -H "Content-Type: OBJECT_CONTENT_TYPE" \
   "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=media&name=OBJECT_NAME&kmsKeyName=KEY_RESOURCE"

   Donde:

   • OBJECT es la ruta de acceso al objeto que deseas subir. Por ejemplo, Desktop/dog.png.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto que deseas subir. Por ejemplo, pets/dog.png.
   • KEY_RESOURCE es el recurso de claves de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

API de XML

Nota: Estos pasos se aplican en específico a la carga de objetos con la API de XML. Puedes seguir un procedimiento similar para redactar o copiar objetos con la API de XML.

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.

2. Agrega los datos del objeto al cuerpo de la solicitud.

3. Usa cURL para llamar a la API de XML con una solicitud de objeto PUT:

   curl -X PUT --data-binary @OBJECT \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   -H "Content-Type: OBJECT_CONTENT_TYPE" \
   -H "x-goog-encryption-kms-key-name: KEY_RESOURCE" \
   "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

   Donde:

   • OBJECT es la ruta de acceso al objeto que deseas subir. Por ejemplo, Desktop/dog.png.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto que deseas subir. Por ejemplo, pets/dog.png.
   • KEY_RESOURCE es el recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

Identifica la clave que se usó para encriptar un objeto

Sigue los pasos a continuación a fin de encontrar el nombre de la clave de Cloud KMS que se usó para encriptar un objeto:

Console

1. Abre el navegador de Cloud Storage en Google Cloud Console.
   Abrir el navegador de Cloud Storage

2. En la lista de bucket s, haz clic en el nombre del bucket que contiene el objeto deseado.

   Se abrirá la página Detalles del bucket y se seleccionará la pestaña Objetos.

3. Navega hasta el objeto, que puede estar en una carpeta.

4. En la columna Encriptación, coloca el cursor sobre la entrada del objeto que desees.

   El nombre de la clave aparece en el siguiente formato:

   LOCATION/KEY_RING_NAME/KEY_NAME/KEY_VERSION

gsutil

Usa el comando gsutil stat:

gsutil stat gs://BUCKET_NAME/OBJECT_NAME

Donde:

• BUCKET_NAME es el nombre del bucket que contiene el objeto encriptado. Por ejemplo, my-bucket.
• OBJECT_NAME es el nombre del objeto encriptado. Por ejemplo, pets/dog.png.

Si tiene éxito, la respuesta contiene el siguiente nombre de la clave:

gs://my-bucket/pets/dog.png:
...
KMS key: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key
...

API de REST

API de JSON

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Usa cURL para llamar a la API de JSON con una solicitud de objeto GET:

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

   Donde:

   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del bucket que contiene el objeto encriptado. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto encriptado. Por ejemplo, pets/dog.png.

API de XML

1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Usa cURL para llamar a la API de XML con una solicitud de objeto GET:

   curl -X GET \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME?encryption"

   Donde:

   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BUCKET_NAME es el nombre del bucket que contiene el objeto encriptado. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto encriptado. Por ejemplo, pets/dog.png.

Nota: Si el objeto se escribió con un método de encriptación distinto al de Cloud KMS, no habrá información asociada con este campo de metadatos.

Desencripta un objeto

Desencriptar un objeto encriptado con una clave de encriptación administrada por el cliente se hace automáticamente siempre que la cuenta de servicio relevante tenga acceso a la clave. Si quieres obtener más información, consulta Cuentas de servicio.

¿Qué sigue?

• Obtén más información sobre las claves de encriptación administradas por el cliente en Cloud Storage.
• Obtén más información sobre otras opciones de encriptación disponibles en Cloud Storage.
• Explora otros productos que pueden funcionar con Cloud KMS.