Schlüsselbund erstellen

Auf dieser Seite erfahren Sie, wie Sie einen Schlüsselbund in Cloud KMS erstellen. Einen Schlüsselbund ist die Stammressource für Cloud KMS-Schlüssel und -Schlüsselversionen. Jeder Schlüsselbund an einem bestimmten Standort existiert. Weitere Informationen zu Cloud KMS finden Sie unter Cloud KMS-Ressourcen.

Hinweise

Bevor Sie die Aufgaben auf dieser Seite ausführen, benötigen Sie Folgendes:

• Eine Google Cloud-Projektressource für Ihr Cloud KMS-Ressourcen. Dieses Projekt wird als Schlüsselprojekt bezeichnet. Mi. empfehlen, dass Ihr Schlüsselprojekt keine anderen Google Cloud-Ressourcen Cloud KMS API für Ihren Schlüssel aktivieren Projekt arbeiten.

  API aktivieren

• Der Name des Standorts, an dem Sie Ihren Schlüsselbund erstellen möchten. Wählen Sie der sich in der Nähe Ihrer anderen Ressourcen befindet und den Schutzniveau. So rufen Sie die verfügbaren Standorte auf: und die unterstützten Schutzniveaus erhalten Sie unter Cloud KMS-Standorte

Erforderliche Rollen

So erhalten Sie die Berechtigungen, die Sie zum Erstellen von Schlüsselbunden benötigen: bitten Sie Ihren Administrator, Ihnen IAM-Rolle Cloud KMS-Administrator (roles/cloudkms.admin) für das Projekt oder eine übergeordnete Ressource. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält Berechtigungen, die zum Erstellen von Schlüsselbunden erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Zum Erstellen von Schlüsselbunden sind die folgenden Berechtigungen erforderlich:

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

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Achtung: Die Cloud KMS-Administratorrolle enthält Berechtigungen für die Schlüsselverwaltung und das Löschen von Schlüsselversionen. Zum Schutz Ihrer Cloud KMS-Ressourcen sollte diese Rolle nur Personen zugewiesen werden, die für die Schlüsselverwaltung verantwortlich sind.

Schlüsselbund erstellen

Führen Sie die folgenden Schritte aus, um einen Schlüsselbund für Ihren neuen Schlüssel zu erstellen. Wenn Sie stattdessen einen vorhandenen Schlüsselbund verwenden möchten, können Sie einen Schlüssel erstellen.

Hinweis: Schlüsselbunde mit demselben Namen können an verschiedenen Standorten vorhanden sein. Geben Sie daher immer den Standort an.

Console

1. Rufen Sie in der Google Cloud Console die Seite Schlüsselverwaltung auf.

   Key Management aufrufen

2. Klicken Sie auf KeyRing erstellen.

3. Geben Sie unter Schlüsselbundname einen Namen für den Schlüsselbund ein.

4. Wählen Sie unter Schlüsselbund-Speicherort einen Standort wie "us-east1" aus.

   Hinweis: Wählen Sie einen Standort in der Nähe der zu schützenden Ressourcen aus. Bei der Verwendung von CMEK sollte sich der Schlüsselbund am selben Speicherort wie die Ressourcen befinden, für die er verwendet wird. Für Cloud EKM-Schlüssel muss der Speicherort physisch sein in der Nähe Ihres EKM-Anbieters (External Key Manager).

5. Klicken Sie auf Erstellen.

gcloud

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

   Activate Cloud Shell

2. Führen Sie in Ihrer Umgebung den Befehl gcloud kms keyrings create aus:

   gcloud kms keyrings create KEY_RING \
       --location LOCATION
   

   Ersetzen Sie Folgendes:

   • KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält
   • LOCATION: der Cloud KMS-Standort des Schlüsselbunds.

   Wenn Sie Informationen zu allen Flags und möglichen Werten erhalten möchten, führen Sie den Befehl mit dem Flag --help aus.

C#

Um diesen Code auszuführen, müssen Sie zuerst eine C#-Entwicklungsumgebung einrichten und das Cloud KMS C# SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Go-Entwicklungsumgebung einrichten und das Cloud KMS Go SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Java-Entwicklungsumgebung einrichten und das Cloud KMS Java SDK installieren.

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

Um diesen Code auszuführen, richten Sie zuerst eine Node.js-Entwicklungsumgebung ein und installieren Sie das Cloud KMS Node.js SDK.

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

Um diesen Code auszuführen, müssen Sie zuerst PHP in Google Cloud verwenden lernen und das Cloud KMS PHP SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Ruby-Entwicklungsumgebung einrichten und das Cloud KMS Ruby SDK installieren.

# 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

In diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

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

Ersetzen Sie Folgendes:

• PROJECT_ID: die ID des Projekts, das den Schlüsselbund enthält.
• KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält.
• LOCATION: der Cloud KMS-Standort des Schlüsselbunds.

Weitere Informationen finden Sie in der KeyRing.create API-Dokumentation.

Nächste Schritte

• Schlüssel erstellen
• Weitere Informationen zum Importieren von Schlüsseln
• Weitere Informationen zum Erstellen externer Schlüssel