Usa claves de encriptación administradas por el cliente

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 introducción a la función, el uso de claves predeterminadas en los depósitos y el agregado 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 detalles sobre esta característica, incluidos los países en los que está disponible, consulta las claves de encriptación administradas por el cliente. Para conocer otras opciones de encriptación en Cloud Storage, consulta las opciones de encriptación de datos.

Requisitos previos

Antes de usar esta característica en Cloud Storage, debes hacer lo siguiente:

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

    Habilitar la API

  2. Obtén los permisos suficientes 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 de 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 son parte de la función roles/cloudkms.admin.

      Consulta el uso de IAM con Cloud KMS para obtener más instrucciones la obtención de estas o algunas otras funciones de Cloud KMS.

  3. Obtén los permisos suficientes para trabajar con objetos en tu depósito de Cloud Storage:

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

    • Si usas IAM, deberías tener el permiso storage.objects.create para escribir objetos en el depósito y storage.objects.get a fin de leer objetos del depósito. Consulta el uso de los permisos de IAMsi deseas recibir instrucciones para obtener una función, como roles/storage.objectAdmin, que tenga estos permisos.

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

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

  5. 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 a fin de usar tu clave de Cloud KMS:

Console

  1. Abre el navegador de las claves de Cloud Key Management Service en Google Cloud Platform Console.
    Abrir el navegador de las 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.

gsutil

Usa el comando gsutil kms authorize a fin de otorgarle a la cuenta de servicio asociada con tu depósito 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 tu 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 Platform Console.

Ejemplos 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#.

        public static void AddMemberToCryptoKeyPolicy(string projectId, string locationId,
            string keyRingId, string cryptoKeyId, string role, string member)
        {
            KeyManagementServiceClient client = KeyManagementServiceClient.Create();
            CryptoKeyName cryptoKeyName =
                new CryptoKeyName(projectId, locationId, keyRingId, cryptoKeyId);

            Policy policy = client.GetIamPolicy(KeyNameOneof.From(cryptoKeyName));
            policy.Bindings.Add(new Binding
            {
                Role = role,
                Members = { member }
            });

            Policy updateResult = client.SetIamPolicy(KeyNameOneof.From(cryptoKeyName), policy);

            foreach (Binding bindingResult in updateResult.Bindings)
            {
                Console.WriteLine($"Role: {bindingResult.Role}");
                foreach (string memberResult in bindingResult.Members)
                {
                    Console.WriteLine($"  Member: {memberResult}");
                }
            }
        }

Go

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	cloudkms "cloud.google.com/go/kms/apiv1"
	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
)

// addMemberRingPolicy adds a new member to a specified IAM role for the key ring.
func addMemberRingPolicy(w io.Writer, keyRingName, member string, role iam.RoleName) error {
	// keyRingName := "projects/PROJECT_ID/locations/global/keyRings/RING_ID"
	// member := "user@gmail.com"
	// role := iam.Viewer
	ctx := context.Background()
	client, err := cloudkms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
	}

	// Get the KeyRing.
	keyRingObj, err := client.GetKeyRing(ctx, &kmspb.GetKeyRingRequest{Name: keyRingName})
	if err != nil {
		return fmt.Errorf("GetKeyRing: %v", err)
	}
	// Get IAM Policy.
	handle := client.KeyRingIAM(keyRingObj)
	policy, err := handle.Policy(ctx)
	if err != nil {
		return fmt.Errorf("Policy: %v", err)
	}
	// Add Member.
	policy.Add(member, role)
	if err = handle.SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("SetPolicy: %v", err)
	}
	fmt.Fprintf(w, "Added member %s to keyring policy.", member)
	return nil
}

Java

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


/**
 * Adds the given member to the given key, with the given role.
 *
 * @param projectId The id of the project.
 * @param locationId The location id of the key.
 * @param keyRingId The id of the keyring.
 * @param cryptoKeyId The id of the crypto key.
 * @param member The member to add. Must be in the proper format, eg:
 *
 * allUsers user:$userEmail serviceAccount:$serviceAccountEmail
 *
 * See https://g.co/cloud/kms/docs/reference/rest/v1/Policy#binding for more details.
 * @param role Must be in one of the following formats: roles/[role]
 * organizations/[organizationId]/roles/[role] projects/[projectId]/roles/[role]
 *
 * See https://g.co/cloud/iam/docs/understanding-roles for available values for [role].
 */
public static Policy addMemberToCryptoKeyPolicy(
    String projectId, String locationId, String keyRingId, String cryptoKeyId, String member,
    String role)
    throws IOException {

  // Create the Cloud KMS client.
  try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

    // The resource name of the cryptoKey version
    String keyName = CryptoKeyName.format(projectId, locationId, keyRingId, cryptoKeyId);

    // Get the current IAM policy
    Policy iamPolicy = client.getIamPolicy(keyName);

    // Create a new binding with the selected role and member
    Binding newBinding = Binding.newBuilder()
        .setRole(role)
        .addMembers(member)
        .build();

    // Create a new IAM policy containing the existing settings plus the new binding.
    Policy newPolicy = Policy.newBuilder()
        .mergeFrom(iamPolicy)
        .addBindings(newBinding)
        .build();

    // Set the new IAM Policy.
    Policy policyResult = client.setIamPolicy(keyName, newPolicy);

    return policyResult;
  }
}

Node.js

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

async function addMemberToCryptoKeyPolicy(
  projectId = 'your-project-id', // Your GCP Project Id
  keyRingId = 'my-key-ring', // Name of the crypto key's key ring
  cryptoKeyId = 'my-key', // Name of the crypto key
  member = 'user:dev@example.com', // Member to add to the crypto key
  role = 'roles/viewer' // Role to give the member
) {
  // Import the library and create a client
  const kms = require('@google-cloud/kms');
  const client = new kms.KeyManagementServiceClient();

  // The location of the crypto key's key ring
  const locationId = 'global';

  // Get the full path to the crypto key
  const resource = client.cryptoKeyPath(
    projectId,
    locationId,
    keyRingId,
    cryptoKeyId
  );

  // Gets the IAM policy of a crypto key
  const [result] = await client.getIamPolicy({resource});
  let policy = Object.assign({bindings: []}, result);
  const index = policy.bindings.findIndex(binding => binding.role === role);

  // Add the role/member combo to the policy
  const members = [];
  const binding = Object.assign({role, members}, policy.bindings[index]);
  if (index === -1) {
    policy.bindings.push(binding);
  }
  if (!binding.members.includes(member)) {
    binding.members.push(member);
  }

  // Adds the member/role combo to the policy of the crypto key
  [policy] = await client.setIamPolicy({resource, policy});
  console.log(
    `${member}/${role} combo added to policy for crypto key ${cryptoKeyId}.`
  );
  if (policy.bindings) {
    policy.bindings.forEach(binding => {
      if (binding.members && binding.members.length) {
        console.log(`${binding.role}:`);
        binding.members.forEach(member => {
          console.log(`  ${member}`);
        });
      }
    });
  } else {
    console.log(`Policy for crypto key ${cryptoKeyId} is empty.`);
  }
}

PHP

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

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

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
// $keyRingId = 'The KMS key ring ID';
// $cryptoKeyId = 'The KMS key ID';
// $member = 'Must be in the format "user:$userEmail" or "serviceAccount:$serviceAccountEmail"';
// $role = 'Must be in the format "roles/$role", "organizations/$organizationId/roles/$role", or "projects/$projectId/roles/$role"';

$kms = new KeyManagementServiceClient();

// The resource name of the CryptoKey.
$cryptoKeyName = $kms->cryptoKeyName($projectId, $locationId, $keyRingId, $cryptoKeyId);

// Get the current IAM policy and add the new account to it.
$policy = $kms->getIamPolicy($cryptoKeyName);
$bindings = $policy->getBindings();
$bindings[] = new Binding([
    'members' => [$member],
    'role' => $role,
]);
$policy->setBindings($bindings);

// Set the new IAM Policy.
$kms->setIamPolicy($cryptoKeyName, $policy);

printf('Member %s added to policy for cryptoKey %s in keyRing %s' . PHP_EOL, $member, $cryptoKeyId, $keyRingId);

Python

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

def add_member_to_crypto_key_policy(
        project_id, location_id, key_ring_id, crypto_key_id, member, role):
    """Adds a member with a given role to the Identity and Access Management
    (IAM) policy for a given CryptoKey associated with a KeyRing."""

    from google.cloud import kms_v1

    # Creates an API client for the KMS API.
    client = kms_v1.KeyManagementServiceClient()

    # The resource name of the CryptoKey.
    resource = client.crypto_key_path_path(project_id, location_id,
                                           key_ring_id, crypto_key_id)
    # Get the current IAM policy.
    policy = client.get_iam_policy(resource)

    # Add member
    policy.bindings.add(
        role=role,
        members=[member])

    # Update the IAM Policy.
    client.set_iam_policy(resource, policy)

    # Print results
    print('Member {} added with role {} to policy for CryptoKey {} \
           in KeyRing {}'.format(member, role, crypto_key_id, key_ring_id))

Ruby

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

# project_id  = "Your Google Cloud project ID"
# location_id = "The location of the key ring"
# key_ring_id = "The ID of the key ring"
# member      = "Member to add to the key ring policy"
# role        = "Role assignment for new member"

require "google/cloud/kms/v1"
CloudKMS = Google::Cloud::Kms::V1

# Initialize the client
client = CloudKMS::KeyManagementServiceClient.new

# The key ring to use
key_ring =
  CloudKMS::KeyManagementServiceClient.key_ring_path project_id, location_id, key_ring_id

# Get the current IAM policy
policy = client.get_iam_policy key_ring

# Add new member to current bindings
policy.bindings ||= []
policy.bindings << Google::Iam::V1::Binding.new(members: [member], role: role)

# Update IAM policy
client.set_iam_policy key_ring, policy

puts "Member #{member} added to policy for " +
     "key ring #{key_ring_id}"

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 propias 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]"
        },
      }
    }

    Donde [SERVICE_ACCOUNT_EMAIL_ADDRESS] es la dirección de correo electrónico asociada con tu cuenta de servicio. Por ejemplo, service-7550275089395@my-pet-project.iam.gserviceaccount.com.

  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 tu recurso de clave de Cloud KMS. Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

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 depósito

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 depósito:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Platform Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el depósito que desees.

  3. Haz clic en Editar depósito en la parte superior de la página.

  4. En la página Editar depósito, haz clic en Mostrar configuración avanzada expandible.

  5. Si el depósito 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.

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption -k [KEY_RESOURCE] gs://[BUCKET_NAME]

Donde:

  • [KEY_RESOURCE] es tu 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 depósito relevante. Por ejemplo, my-bucket.

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

Authorized service account [SERVICE_ACCOUNT_NAME] to use key:
[KEY_RESOURCE]

Ejemplos 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++.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string key_name) {
  StatusOr<gcs::BucketMetadata> updated_metadata = client.PatchBucket(
      bucket_name, gcs::BucketMetadataPatchBuilder().SetEncryption(
                       gcs::BucketEncryption{key_name}));

  if (!updated_metadata) {
    throw std::runtime_error(updated_metadata.status().message());
  }

  if (!updated_metadata->has_encryption()) {
    std::cerr << "The change to set the encryption attribute on bucket "
              << updated_metadata->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_metadata->name() << " to "
            << updated_metadata->encryption().default_kms_key_name << "."
            << "\nFull metadata: " << *updated_metadata << "\n";
}

C#

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

private void AddBucketDefaultKmsKey(string bucketName,
    string keyLocation, string kmsKeyRing, string kmsKeyName)
{
    string KeyPrefix = $"projects/{s_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, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Go

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

bucket := c.Bucket(bucketName)
bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
	Encryption: &storage.BucketEncryption{DefaultKMSKeyName: keyName},
}
if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
	return err
}

Java

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

// 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.

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

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

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

// Enables a default KMS key for the bucket
await storage.bucket(bucketName).setMetadata({
  encryption: {
    defaultKmsKeyName,
  },
});

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

PHP

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

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.

"""Sets a bucket's default KMS 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.

# project_id      = "Your Google Cloud project ID"
# bucket_name     = "Name of your Google Cloud Storage bucket"
# default_kms_key = "KMS key resource id"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
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}"

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 propias credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
      "encryption": {
        "defaultKmsKeyName": "[KEY_RESOURCE]"
      }
    }

    Donde [KEY_RESOURCE] es tu recurso de claves 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 depósito PATCH:

    curl -X PATCH --data-binary @[JSON_FILE_NAME].json \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: application/json" \
    "https://www.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 relevante. 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 propias credenciales de OAuth.
  2. Crea un archivo .xml que contenga la siguiente información:

    <EncryptionConfiguration>
      <DefaultKmsKeyName>[KEY_RESOURCE]</DefaultKmsKeyName>
    </EncryptionConfiguration>

    Donde [KEY_RESOURCE] es tu recurso de claves 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 depósito PUT y un parámetro encryption de string de consulta:

    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 relevante. Por ejemplo, my-bucket.

Ve la clave predeterminada de un depósito

Sigue los pasos a continuación para ver la clave de Cloud KMS que se encuentra configurada como predeterminada en tu depósito:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Platform Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el depósito que desees.

  3. En la página de detalles del depósito, haz clic en la pestaña Descripción general.

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

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption gs://[BUCKET_NAME]

Donde [BUCKET_NAME] es el nombre del depósito cuya clave deseas ver. Por ejemplo, my-bucket.

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

Default encryption key for gs://[BUCKET_NAME]:
[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 propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de depósito GET que incluya el fields deseado:

    curl -X GET -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://www.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 depósito 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 propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de XML con una solicitud de depósito 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 depósito 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 depósito

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

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Platform Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el depósito que desees.

  3. Haz clic en Editar depósito en la parte superior de la página.

  4. En la página Editar depósito, haz clic en Mostrar configuración avanzada expandible.

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

  6. Haz clic en Guardar.

gsutil

Usa el comando gsutil kms encryption:

gsutil kms encryption -d gs://[BUCKET_NAME]

En el que [BUCKET_NAME] es el nombre del depósito relevante. Por ejemplo, my-bucket.

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

Clearing default encryption key for gs://[BUCKET_NAME]...

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 propias 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 depósito PATCH:

    curl -X PATCH --data-binary @[JSON_FILE_NAME].json \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: application/json" \
    "https://www.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 relevante. 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 propias 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 depósito PUT y un parámetro encryption de string de consulta:

    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 relevante. Por ejemplo, my-bucket.

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 predeterminada establecida en el depósito o si no tienes una clave predeterminada.

Console

GCP 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]

    Donde [KEY_RESOURCE] es tu recurso de claves de Cloud KMS . Por ejemplo, projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

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

Ejemplos 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++.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string kms_key_name) {
  gcs::ObjectWriteStream stream = client.WriteObject(
      bucket_name, object_name, gcs::KmsKeyName(kms_key_name));

  // Line numbers start at 1.
  for (int lineno = 1; lineno <= 10; ++lineno) {
    stream << lineno << ": placeholder text for CMEK example.\n";
  }

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();

  if (!metadata) {
    throw std::runtime_error(metadata.status().message());
  }

  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\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#.

        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.

obj := client.Bucket(bucket).Object(object)
// Encrypt the object's contents
wc := obj.NewWriter(ctx)
wc.KMSKeyName = keyName
if _, err := wc.Write([]byte("top secret")); err != nil {
	return err
}
if err := wc.Close(); err != nil {
	return err
}

Java

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

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

Node.js

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

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

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

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

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

PHP

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

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.

"""Uploads a file to the bucket, encrypting it with the given KMS key."""
storage_client = storage.Client()
bucket = storage_client.get_bucket(bucket_name)
blob = bucket.blob(destination_blob_name, kms_key_name=kms_key_name)
blob.upload_from_filename(source_file_name)

print('File {} uploaded to {} with encryption key {}.'.format(
    source_file_name,
    destination_blob_name,
    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.

# project_id        = "Your Google Cloud project ID"
# bucket_name       = "Your Google Cloud Storage bucket name"
# local_file_path   = "Path to local file to upload"
# storage_file_path = "Path to store the file in Google Cloud Storage"
# kms_key           = "KMS key resource id"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id

bucket = storage.bucket bucket_name

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

puts "Uploaded #{file.name} and encrypted service side using #{file.kms_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 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://www.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 depósito 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

  1. Obtén un token de acceso de autorización 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 depósito 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 tu 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 usa 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 Platform Console.
    Abrir el navegador de Cloud Storage
  2. Navega hasta el objeto que desees en el depósito correspondiente.

  3. En la columna de 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 depósito 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://[BUCKET_NAME]/[OBJECT_NAME]:
...
KMS key: [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 propias 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://www.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 depósito 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 propias 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 depósito que contiene el objeto encriptado. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto encriptado. Por ejemplo, pets/dog.png.

Desencripta un objeto

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

Próximos pasos

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.