Utiliser les clés de chiffrement gérées par le client

Vous trouverez sur cette page la procédure à suivre pour utiliser une clé de chiffrement Cloud Key Management Service avec Cloud Storage, y compris les premiers pas avec la fonctionnalité, l'utilisation des clés par défaut sur des buckets et l'ajout de clés à des objets individuels. La clé de chiffrement Cloud KMS est une clé de chiffrement gérée par le client, que Cloud KMS crée et que vous gérez. Pour en savoir plus sur cette fonctionnalité et obtenir la liste des pays où elle est disponible, consultez la page Clés de chiffrement gérées par le client. Pour connaître les autres options de chiffrement dans Cloud Storage, consultez la section Options de chiffrement des données.

Prérequis

Avant d'utiliser cette fonctionnalité dans Cloud Storage, vous devez répondre aux critères suivants :

  1. Avoir activé l'API Cloud KMS pour le projet qui stockera vos clés de chiffrement

    Activer l'API

  2. Disposer des autorisations suffisantes sur le projet qui stockera vos clés de chiffrement :

    • Si vous êtes le propriétaire du projet qui stockera les clés, vous disposez probablement de l'autorisation nécessaire.

    • Si vous envisagez de créer des trousseaux de clés et des clés de chiffrement, vous devez disposer des autorisations cloudkms.keyRings.create et cloudkms.cryptoKey.create.

    • Que vous prévoyiez d'utiliser des clés et des trousseaux de clés nouveaux ou existants, vous devez bénéficier de l'autorisation cloudkms.cryptoKey.setIamPolicy pour les clés qui serviront au chiffrement.

      Cette autorisation vous permet d'accorder aux comptes de service Cloud Storage un accès aux clés Cloud KMS.

    • Les autorisations ci-dessus sont comprises dans le rôle roles/cloudkms.admin.

      Reportez-vous à la section Utiliser IAM avec Cloud KMS pour savoir comment obtenir ce rôle ou d'autres rôles de Cloud KMS.

  3. Disposer des autorisations suffisantes pour utiliser des objets dans votre bucket Cloud Storage :

    • Si vous êtes propriétaire du projet contenant le bucket, vous disposez probablement de l'autorisation nécessaire.

    • Si vous utilisez IAM, vous devez disposer de l'autorisation storage.objects.create pour écrire des objets sur le bucket et de l'autorisation storage.objects.get pour lire des objets à partir de ce bucket. Consultez la page Utiliser les autorisations IAM pour savoir comment obtenir un rôle, tel que roles/storage.objectAdmin, disposant de ces autorisations.

    • Si vous utilisez des LCA (Listes de contrôle des accès), vous devez disposer de l'autorisation WRITER (rédacteur) au niveau du bucket pour écrire des objets sur le bucket et de l'autorisation READER (lecteur) au niveau des objets pour lire des objets à partir de ce bucket. Pour savoir comment procéder, consultez la section Configurer des LCA.

  4. Disposer d'un trousseau de clés Cloud KMS qui compte au moins une clé

  5. Obtenir l'adresse e-mail du compte de service associé au projet contenant votre bucket Cloud Storage.

Attribuer une clé Cloud KMS à un compte de service

Pour pouvoir utiliser les clés de chiffrement gérées par le client, accordez à votre compte de service Cloud Storage l'autorisation d'utiliser votre clé Cloud KMS :

Console

  1. Ouvrez le navigateur de clés Cloud Key Management Service dans la console Google Cloud Platform.
    Ouvrir le navigateur de clés Cloud KMS
  2. Cliquez sur le nom du trousseau contenant la clé souhaitée.

  3. Cochez la case correspondant à la clé souhaitée.

    L'onglet Autorisations s'affiche dans le volet de droite.

  4. Dans la boîte de dialogue Ajouter des membres, indiquez l'adresse e-mail du compte de service Cloud Storage auquel vous accordez l'accès.

  5. Dans le menu déroulant Sélectionner un rôle, sélectionnez Chiffreur/Déchiffreur de clés cryptographiques Cloud KMS.

  6. Cliquez sur Ajouter.

gsutil

Exécutez la commande gsutil kms authorize pour accorder au compte de service associé à votre bucket l'autorisation de chiffrer et de déchiffrer des objets à l'aide de votre clé Cloud KMS, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

Si vous souhaitez supprimer l'autorisation accordée, vous devez utiliser l'outil de ligne de commande gcloud ou la console Google Cloud Platform.

Exemples de code

C#

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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 REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json contenant les informations suivantes en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

    {
      "policy": {
        "bindings": {
          "role": "roles/cloudkms.cryptoKeyEncrypterDecrypter",
          "members": "[SERVICE_ACCOUNT_EMAIL_ADDRESS]"
        },
      }
    }
  3. Exécutez cURL pour appeler l'API Cloud KMS avec une requête POST setIamPolicy, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

    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"

    Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

API XML

L'API XML ne peut pas être utilisée pour affecter un Cloud KMS à un compte de service. Il faut utiliser l'un des autres outils de Cloud Storage, tels que gsutil.

Utiliser les clés de chiffrement par défaut

Ajouter ou modifier la clé par défaut d'un bucket

Pour ajouter ou modifier la clé Cloud KMS utilisée par défaut lorsque des objets sont écrits sur un bucket, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le bucket souhaité.

  3. Cliquez sur Modifier le bucket en haut de la page.

  4. Sur la page "Modifier le bucket", cliquez sur le menu déroulant Afficher les paramètres avancés.

  5. Si le bucket n'utilise pas actuellement de clé Cloud KMS, cochez la case d'option Clé gérée par le client.

  6. Dans le menu déroulant correspondant aux clés gérées par le client, sélectionnez l'une des clés disponibles.

  7. Cliquez sur Save.

gsutil

Exécutez la commande gsutil kms encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

Si l'opération réussit, la réponse se présente comme suit :

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

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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#

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage Go.

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

Java

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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 REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json contenant les informations suivantes en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

  3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

    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 XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .xml contenant les informations suivantes en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

  3. Exécutez cURL pour appeler l'API XML avec une requête de bucket PUT et un paramètre de chaîne de requête encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Afficher la clé par défaut d'un bucket

Pour afficher la clé Cloud KMS actuellement définie comme clé par défaut de votre bucket, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le bucket souhaité.

  3. Dans la page d'informations sur le bucket, cliquez sur l'onglet Vue d'ensemble.

  4. La clé par défaut actuelle de votre bucket apparaît dans le champ Clé de chiffrement.

gsutil

Exécutez la commande gsutil kms encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

gsutil kms encryption gs://[BUCKET_NAME]

Si l'opération réussit, la réponse se présente comme suit :

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

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API JSON avec une requête de bucket GET qui inclut les champs fields souhaités, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    La réponse se présente comme suit :

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

API XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API XML avec une requête de bucket GET qui inclut le paramètre de requête encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    La réponse se présente comme suit :

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

Supprimer la clé par défaut d'un bucket

Pour supprimer les clé Cloud KMS définies par défaut sur un bucket, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le bucket souhaité.

  3. Cliquez sur Modifier le bucket en haut de la page.

  4. Sur la page "Modifier le bucket", cliquez sur le menu déroulant Afficher les paramètres avancés.

  5. Cochez la case d'option Clé gérée par Google.

  6. Cliquez sur Save.

gsutil

Exécutez la commande gsutil kms encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Si l'opération réussit, la réponse se présente comme suit :

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

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json contenant les informations suivantes :

    {
      "encryption": {
        "defaultKmsKeyName": null
      }
    }
  3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

    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 XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .xml contenant les informations suivantes :

    <EncryptionConfiguration></EncryptionConfiguration>
  3. Exécutez cURL pour appeler l'API XML avec une requête de bucket PUT et un paramètre de chaîne de requête encryption, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Chiffrer un objet avec une clé Cloud KMS

Vous pouvez chiffrer un objet individuel avec une clé Cloud KMS. Ceci est utile si vous souhaitez utiliser une clé différente de celle définie par défaut sur le bucket ou si aucune clé par défaut n'est définie sur le bucket.

Console

La console GCP ne peut pas être utilisée pour chiffrer des objets individuels. Il faut utiliser l'outil gsutil ou les bibliothèques clientes.

gsutil

  1. Ajoutez l'option suivante à la section [GSUtil] de votre fichier de configuration .boto :

    encryption_key = [KEY_RESOURCE]

    Consultez la section Ressources de clés pour connaître le format attendu pour votre clé.

  2. Écrivez un objet sur le bucket comme vous le feriez habituellement, par exemple avec gsutil cp ou gsutil rewrite.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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#

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour plus d'informations, consultez la documentation de référence de l'API Cloud Storage en langage 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 REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Ajoutez les données de l'objet au corps de la requête.

  3. Exécutez cURL pour appeler l'API JSON avec une requête d'objet POST en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

API XML

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Ajoutez les données de l'objet au corps de la requête.

  3. Exécutez cURL pour appeler l'API XML avec une requête d'objet PUT en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

    Consultez la section Ressources de clés pour connaître le format attendu pour [KEY_RESOURCE].

Identifier la clé utilisée pour chiffrer un objet

Pour trouver le nom de la clé Cloud KMS utilisée pour chiffrer un objet, procédez comme suit :

Console

  1. Ouvrez le navigateur Cloud Storage dans la console Google Cloud Platform.
    Ouvrir le navigateur Cloud Storage
  2. Accédez à l'objet souhaité dans le bucket correspondant.

  3. Dans la colonne Chiffrement, passez la souris sur l'entrée de l'objet souhaité.

    Le nom de la clé apparaît au format suivant :

    [LOCATION]/[KEY_RING_NAME]/[KEY_NAME]

gsutil

Exécutez la commande gsutil ls avec l'indicateur -L, en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Si l'opération réussit, la réponse contient le nom de la clé :

gs://[BUCKET_NAME]/[OBJECT_NAME]:
...
KMS key: [KEY_RESOURCE]
...

API REST

API JSON

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API JSON avec une requête d'objet GET en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

API XML

  1. Obtenez un jeton d'accès d'autorisation sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Exécutez cURL pour appeler l'API XML avec une requête d'objet GET en remplaçant les éléments entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

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

Déchiffrer un objet

Le déchiffrement d'un objet chiffré avec une clé de chiffrement gérée par le client s'effectue automatiquement, à condition que le compte de service concerné ait accès à la clé. Pour en savoir plus, consultez la section Comptes de service avec des clés de chiffrement gérées par le client.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.