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, que incluye cómo comenzar con la función mediante el uso de las claves predeterminadas de 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 detalles sobre esta función, incluidos los países donde está disponible, consulta las Claves de encriptación administradas por el cliente. Para conocer otras opciones de encriptación en Cloud Storage, consulta Opciones de encriptación de datos.

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 de cloudkms.keyRings.create y cloudkms.cryptoKey.create.

    • Ya sea que planees usar claves o llaveros de claves nuevos o existentes, debes tener permisos cloudkms.cryptoKey.setIamPolicy para las claves que vas a usar en la encriptación.

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

    • Los permisos anteriores están contenidos en las funciones roles/cloudkms.admin.

      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 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, debes tener el permiso de storage.objects.create a fin de escribir objetos al depósito y permiso de storage.objects.get para leer objetos desde el depósito. Consulta Usa los permisos de IAM para más instrucciones sobre cómo obtener una función, como roles/storage.objectAdmin, que incluye estos permisos.

    • Si usas las LCA, debes tener permiso de WRITER en el depósito de alcance a fin de escribir objetos al depósito, y permiso de READER en el depósito de alcance para leer objetos del depósito. Consulta Configura las LCA para obtener instrucciones sobre cómo realizar esto.

  4. Ten un llavero de claves de Cloud KMS y ten al menos una clave dentro del llavero de claves.

  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 para 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 otorgar a la cuenta de servicio asociada con tu permiso de depósito para encriptar y desencriptar objetos con tu clave de Cloud KMS y reemplaza [VALUES_IN_BRACKETS] por los valores asociados.

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

Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

Si deseas quitar el permiso que se otorgó, debes usar la herramienta de línea de comandos de gcloud o Google Cloud Platform Console.

Muestras de código

C#

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

            Binding binding = new Binding();
            binding.Role = role;
            binding.Members.Add(member);

            policy.Bindings.Add(binding);

            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 quieres obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

// addMemberRingPolicy adds a new member to a specified IAM role for the key ring
// example keyRingName: "projects/PROJECT_ID/locations/global/keyRings/RING_ID"
func addMemberRingPolicy(keyRingName, member string, role iam.RoleName) error {
	ctx := context.Background()
	client, err := cloudkms.NewKeyManagementClient(ctx)
	if err != nil {
		return err
	}

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

Java

Si quieres 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 quieres 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 quieres 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 quieres 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."""

    # 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 quieres 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

    {
      "policy": {
        "bindings": {
          "role": "roles/cloudkms.cryptoKeyEncrypterDecrypter",
          "members": "[SERVICE_ACCOUNT_EMAIL_ADDRESS]"
        },
      }
    }
  3. Usa cURL para llamar a la API de Cloud KMS con una solicitud POST setIamPolicy y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

    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"

    Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados.

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

Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

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

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

Muestras de código

C++

Si quieres 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.ok()) {
    std::cerr << "Error updating the metadata for bucket " << bucket_name
              << ", status=" << updated_metadata.status() << std::endl;
    return;
  }
  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?"
              << std::endl;
    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 << std::endl;
}

C#

Si quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

  3. Usa cURL para llamar a la API de JSON con una solicitud de depósito PATCH y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

    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"

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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

  3. Usa cURL para llamar a la API de XML con una solicitud de depósito PUT y el parámetro de string de consulta encryption, y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

Ve la clave predeterminada de un depósito

Sigue los pasos a continuación para ver la clave de Cloud KMS que actualmente está 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 su grupo depósito aparece en el campo Clave de encriptación.

gsutil

Usa el comando gsutil kms encryption y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados.

gsutil kms encryption gs://[BUCKET_NAME]

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 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 los fields deseados y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    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 incluye el parámetro de consulta encryption y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    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 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. Selecciona el botón de selección Clave administrada por Google.

  6. Haz clic en Guardar.

gsutil

Usa el comando gsutil kms encryption y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados.

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

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 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

    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"

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 el parámetro de string de consulta encryption, y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

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

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]

    Consulta los Recursos de las claves para obtener el formato esperado de tu clave.

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

Muestras de código

C++

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

namespace gcs = google::cloud::storage;
[](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();
  gcs::ObjectMetadata meta = stream.metadata().value();
  std::cout << "The resulting object size is: " << meta.size() << std::endl;
}

C#

Si quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 quieres 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Consulta los Recursos de las claves para obtener el formato esperado [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. 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Consulta los Recursos de las claves para obtener el formato esperado [KEY_RESOURCE].

Identifica la clave que 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, desplaza el mouse sobre la entrada del objeto que desees.

    El nombre de la clave aparece en el siguiente formato:

    [LOCATION]/[KEY_RING_NAME]/[KEY_NAME]

gsutil

Usa el comando gsutil ls con la marca -L y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

gsutil ls -L gs://[BUCKET_NAME]/[OBJECT_NAME]

Si es correcto, 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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

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 y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

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 con claves de encriptación administradas por el cliente.

¿Qué sigue?

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

Enviar comentarios sobre...

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