Usa claves de encriptación administradas por el cliente

En esta página se describe cómo usar una clave de encriptación del servicio de administración de claves con Cloud Storage, lo que incluye la introducción a la función, el uso de claves predeterminadas en depósitos y la incorporación de claves a objetos individuales. La clave de encriptación de KMS es una clave de encriptación administrada por el cliente que KMS crea y que tú administras. Para obtener más detalles sobre esta función, incluidos los países en los que está disponible, consulta Usa 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 función en Cloud Storage, ten en cuenta lo siguiente:

  1. Habilita la API de KMS del proyecto en el que se almacenarán 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 cloudkms.cryptoKey.setIamPolicy para las claves que usarás en la encriptación.

      Si tienes este permiso, puedes otorgar a las cuentas de servicio de Cloud Storage acceso a las claves de KMS.

    • Los permisos anteriores se encuentran en la función roles/cloudkms.admin.

      Consulta Usa IAM con Cloud KMS a fin de recibir instrucciones para obtener estas o algunas otras funciones de 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. Debes tener un llavero de claves de 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 KMS a una cuenta de servicio

A fin de 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 KMS:

Console

  1. Abre el navegador de las claves del servicio de administración de claves en Google Cloud Console.
    Abrir el navegador de claves de 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 otorgar a la cuenta de servicio asociada con tu depósito el permiso para encriptar y desencriptar objetos con tu clave de KMS:

gsutil kms authorize -p [PROJECT_STORING_OBJECTS] -k [KEY_RESOURCE]

En este comando, se muestra lo siguiente:

  • [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 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 autorización de acceso 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 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"

    En esta solicitud, se muestra lo siguiente:

    • [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 un 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

Para agregar o cambiar la clave de KMS que se usa de forma predeterminada cuando los objetos se escriben en un depósito, sigue estos pasos:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud 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 el botón expandible Mostrar configuración avanzada.

  5. Si el depósito no usa en la actualidad una clave de 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]

En este comando, se muestra lo siguiente:

  • [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 es correcto, la respuesta se parece al siguiente ejemplo:

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 autorización de acceso 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]"
      }
    }

    En el que [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.

  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://storage.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=encryption"

    En esta solicitud, se muestra lo siguiente:

    • [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 autorización de acceso 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>

    En el que [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.

  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"

    En esta solicitud, se muestra lo siguiente:

    • [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

Para ver la clave de KMS que está configurada de forma predeterminada en tu depósito, sigue estos pasos:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud 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 es correcto, la respuesta se parece al siguiente ejemplo:

Default encryption key for gs://[BUCKET_NAME]:
[KEY_RESOURCE]

API de REST

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. Usa cURL para llamar a la API de JSON con una solicitud de depósito 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"

    En esta solicitud, se muestra lo siguiente:

    • [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 autorización de acceso 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"

    En esta solicitud, se muestra lo siguiente:

    • [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

Para quitar cualquier conjunto de claves de KMS predeterminadas de un depósito, sigue estos pasos:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud 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 el botón expandible Mostrar configuración avanzada.

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

Si es correcto, la respuesta se parece al siguiente ejemplo:

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

API de REST

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. 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://storage.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=encryption"

    En esta solicitud, se muestra lo siguiente:

    • [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 autorización de acceso 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"

    En esta solicitud, se muestra lo siguiente:

    • [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 KMS

Puedes encriptar un objeto individual con una clave de 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

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 que [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.

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

    En esta solicitud, se muestra lo siguiente:

    • [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 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]"

    En esta solicitud, se muestra lo siguiente:

    • [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

A fin de encontrar el nombre de la clave de KMS que se usó para encriptar un objeto, haz lo siguiente:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. Navega hasta el objeto que desees en el depósito correspondiente.

  3. 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]

En este comando, se muestra lo siguiente:

  • [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 autorización de acceso 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://storage.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]?fields=kmsKeyName"

    En esta solicitud, se muestra lo siguiente:

    • [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 autorización de acceso 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"

    En esta solicitud, se muestra lo siguiente:

    • [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

La desencriptación de un objeto encriptado con una clave de encriptación administrada por el cliente se realiza 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.

Próximos pasos

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

Enviar comentarios sobre...

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