Crea un llavero de claves

En esta página, se muestra cómo crear un llavero de claves en Cloud KMS. Un llavero de claves es el recurso raíz de las claves y versiones de claves de Cloud KMS. Cada llavero de claves existe dentro de una ubicación determinada. Para obtener más información sobre los recursos de Cloud KMS, consulta Recursos de Cloud KMS.

Antes de comenzar

Antes de completar las tareas de esta página, debes tener lo siguiente:

• Un recurso de proyecto de Google Cloud para contener tus recursos de Cloud KMS. Este proyecto se denomina proyecto de clave. Te recomendamos que tu proyecto clave no contenga ningún otro recurso de Google Cloud. Habilita la API de Cloud KMS en tu proyecto de claves.

  Habilitar la API

• Es el nombre de la ubicación en la que deseas crear el llavero de claves. Elige una ubicación que esté cerca de tus otros recursos y que admita el nivel de protección que elegiste. Para ver las ubicaciones disponibles y los niveles de protección que admiten, consulta Ubicaciones de Cloud KMS.

Roles obligatorios

Para obtener los permisos que necesitas para crear anillos de claves, pídele a tu administrador que te otorgue el rol de IAM de Administrador de Cloud KMS (roles/cloudkms.admin) en el proyecto o en un recurso superior. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear llaveros. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear llaveros:

• cloudkms.keyRings.create
• cloudkms.keyRings.get
• cloudkms.keyRings.list
• cloudkms.locations.get
• cloudkms.locations.list
• resourcemanager.projects.get

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Precaución: El rol de administrador de Cloud KMS contiene permisos para el mantenimiento y la destrucción de versiones de claves. Para proteger tus recursos de Cloud KMS, este rol solo se debe asignar a las personas responsables de la administración de claves.

Crea un llavero de claves

Sigue estos pasos a fin de crear un llavero de claves para tu clave nueva. En cambio, si deseas usar un llavero de claves existente, puedes crear una clave.

Nota: Los llaveros de claves con el mismo nombre pueden existir en diferentes ubicaciones, por lo que siempre debes especificar la ubicación.

Console

1. Ve a la página Administración de claves en la consola de Google Cloud.

   Ir a Key Management

2. Haz clic en Crear llavero de claves.

3. En Nombre del llavero de claves, ingresa un nombre para tu llavero de claves.

4. En Ubicación del llavero de claves, selecciona una ubicación, como "us-east1".

   Nota: Elige una ubicación que esté cerca de los recursos que deseas proteger. Para usar CMEK, el llavero de claves debe estar en la misma ubicación que los recursos con los que lo usas. Para las claves de Cloud EKM, la ubicación debe estar físicamente cerca del proveedor de tu administrador de claves externo (EKM).

5. Haz clic en Crear.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

2. En tu entorno, ejecuta el comando gcloud kms keyrings create:

   gcloud kms keyrings create KEY_RING \
       --location LOCATION
   

   Reemplaza lo siguiente:

   • KEY_RING: Es el nombre del llavero de claves que contiene la clave.
   • LOCATION: Es la ubicación de Cloud KMS del llavero de claves.

   Para obtener información sobre todas las marcas y los valores posibles, ejecuta el comando con la marca --help.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# e instala el SDK de C# para Cloud KMS.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Kms.V1;

public class CreateKeyRingSample
{
    public KeyRing CreateKeyRing(
      string projectId = "my-project", string locationId = "us-east1",
      string id = "my-key-ring")
    {
        // Create the client.
        KeyManagementServiceClient client = KeyManagementServiceClient.Create();

        // Build the parent location name.
        LocationName locationName = new LocationName(projectId, locationId);

        // Build the key ring.
        KeyRing keyRing = new KeyRing { };

        // Call the API.
        KeyRing result = client.CreateKeyRing(locationName, id, keyRing);

        // Return the result.
        return result;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Cloud KMS.

import (
	"context"
	"fmt"
	"io"

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

// createKeyRing creates a new ring to store keys on KMS.
func createKeyRing(w io.Writer, parent, id string) error {
	// parent := "projects/PROJECT_ID/locations/global"
	// id := "my-key-ring"

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

	// Build the request.
	req := &kmspb.CreateKeyRingRequest{
		Parent:    parent,
		KeyRingId: id,
	}

	// Call the API.
	result, err := client.CreateKeyRing(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create key ring: %w", err)
	}
	fmt.Fprintf(w, "Created key ring: %s\n", result.Name)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Cloud KMS.

import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.cloud.kms.v1.KeyRing;
import com.google.cloud.kms.v1.LocationName;
import java.io.IOException;

public class CreateKeyRing {

  public void createKeyRing() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String id = "my-asymmetric-signing-key";
    createKeyRing(projectId, locationId, id);
  }

  // Create a new key ring.
  public void createKeyRing(String projectId, String locationId, String id) throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the parent name from the project and location.
      LocationName locationName = LocationName.of(projectId, locationId);

      // Build the key ring to create.
      KeyRing keyRing = KeyRing.newBuilder().build();

      // Create the key ring.
      KeyRing createdKeyRing = client.createKeyRing(locationName, id, keyRing);
      System.out.printf("Created key ring %s%n", createdKeyRing.getName());
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Cloud KMS.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const id = 'my-key-ring';

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

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

// Build the parent location name
const locationName = client.locationPath(projectId, locationId);

async function createKeyRing() {
  const [keyRing] = await client.createKeyRing({
    parent: locationName,
    keyRingId: id,
  });

  console.log(`Created key ring: ${keyRing.name}`);
  return keyRing;
}

return createKeyRing();

PHP

Para ejecutar este código, primero obtén información sobre cómo usar PHP en Google Cloud y, luego, instala el SDK de PHP para Cloud KMS.

use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;
use Google\Cloud\Kms\V1\CreateKeyRingRequest;
use Google\Cloud\Kms\V1\KeyRing;

function create_key_ring(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $id = 'my-key-ring'
): KeyRing {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the parent location name.
    $locationName = $client->locationName($projectId, $locationId);

    // Build the key ring.
    $keyRing = new KeyRing();

    // Call the API.
    $createKeyRingRequest = (new CreateKeyRingRequest())
        ->setParent($locationName)
        ->setKeyRingId($id)
        ->setKeyRing($keyRing);
    $createdKeyRing = $client->createKeyRing($createKeyRingRequest);
    printf('Created key ring: %s' . PHP_EOL, $createdKeyRing->getName());

    return $createdKeyRing;
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

from google.cloud import kms


def create_key_ring(
    project_id: str, location_id: str, key_ring_id: str
) -> kms.CryptoKey:
    """
    Creates a new key ring in Cloud KMS

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the key ring to create (e.g. 'my-key-ring').

    Returns:
        KeyRing: Cloud KMS key ring.

    """

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

    # Build the parent location name.
    location_name = f"projects/{project_id}/locations/{location_id}"

    # Build the key ring.
    key_ring = {}

    # Call the API.
    created_key_ring = client.create_key_ring(
        request={
            "parent": location_name,
            "key_ring_id": key_ring_id,
            "key_ring": key_ring,
        }
    )
    print(f"Created key ring: {created_key_ring.name}")
    return created_key_ring

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby para Cloud KMS.

# TODO(developer): uncomment these values before running the sample.
# project_id  = "my-project"
# location_id = "us-east1"
# id = "my-key-ring"

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

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

# Build the parent location name.
location_name = client.location_path project: project_id, location: location_id

# Build the key ring.
key_ring = {}

# Call the API.
created_key_ring = client.create_key_ring parent: location_name, key_ring_id: id, key_ring: key_ring
puts "Created key ring: #{created_key_ring.name}"

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings?key_ring_id=KEY_RING" \
    --request "POST" \
    --header "authorization: Bearer TOKEN"

Reemplaza lo siguiente:

• PROJECT_ID: El ID del proyecto que contiene el llavero.
• KEY_RING: Es el nombre del llavero de claves que contiene la clave.
• LOCATION: Es la ubicación de Cloud KMS del llavero de claves.

Consulta la documentación sobre la API de KeyRing.create para obtener más información.

¿Qué sigue?

• Aprende cómo crear una clave.
• Obtén más información para importar claves.
• Obtén más información para crear claves externas.