Crie um conjunto de chaves

Esta página mostra-lhe como criar um conjunto de chaves no Cloud KMS. Um conjunto de chaves é o recurso raiz para chaves e versões de chaves do Cloud KMS. Cada porta-chaves existe numa determinada localização. Para mais informações sobre os recursos do Cloud KMS, consulte o artigo Recursos do Cloud KMS.

Antes de começar

Antes de concluir as tarefas nesta página, precisa do seguinte:

  • Um recurso de projeto para conter os seus recursos do Cloud KMS. Google Cloud Este projeto é denominado o seu projeto principal. Recomendamos que o seu projeto principal não contenha outros recursos.Google Cloud Ative a API Cloud KMS no projeto da chave.

    Ative a API

  • O nome da localização onde quer criar o seu porta-chaves. Escolha uma localização perto dos seus outros recursos e que suporte o nível de proteção escolhido. Para ver as localizações disponíveis e os níveis de proteção que suportam, consulte o artigo Localizações do Cloud KMS.

Funções necessárias

Para obter as autorizações de que precisa para criar conjuntos de chaves, peça ao seu administrador que lhe conceda a função administrador do Cloud KMS (roles/cloudkms.admin) da IAM no projeto ou num recurso principal. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém as autorizações necessárias para criar conjuntos de chaves. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

As seguintes autorizações são necessárias para criar conjuntos de chaves:

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

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Crie um conjunto de chaves

Siga estes passos para criar um porta-chaves para a sua nova chave. Se quiser usar um conjunto de chaves existente, pode criar uma chave.

Consola

  1. Aceda à página Gestão de chaves na Google Cloud consola.

    Aceda à gestão de chaves

  2. Clique em Criar conjunto de chaves.

  3. Em Nome do conjunto de chaves, introduza um nome para o conjunto de chaves.

  4. Para Localização do porta-chaves, selecione uma localização, como "us-east1".

  5. Clique em Criar.

gcloud

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

    Activate Cloud Shell

  2. No seu ambiente, execute o comando gcloud kms keyrings create:

    gcloud kms keyrings create KEY_RING \
        --location LOCATION
    

    Substitua o seguinte:

    • KEY_RING: o nome do conjunto de chaves que contém a chave.
    • LOCATION: a localização do Cloud KMS do conjunto de chaves.

    Para ver informações sobre todas as flags e valores possíveis, execute o comando com a flag --help.

  3. C#

    Para executar este código, primeiro configure um ambiente de desenvolvimento C# e instale o SDK C# do 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 executar este código, primeiro configure um ambiente de desenvolvimento Go e instale o SDK Go do 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 executar este código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK Java do 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 executar este código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Node.js do 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 executar este código, saiba primeiro como usar o PHP no Google Cloud e instale o SDK PHP do 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 executar este código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK Python do 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 executar este código, primeiro configure um ambiente de desenvolvimento Ruby e instale o SDK Ruby do 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

    Estes exemplos usam o curl como cliente HTTP para demonstrar a utilização da API. Para mais informações sobre o controlo de acesso, consulte o artigo Aceder à API 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"
    

    Substitua o seguinte:

    • PROJECT_ID: o ID do projeto que contém o conjunto de chaves.
    • KEY_RING: o nome do conjunto de chaves que contém a chave.
    • LOCATION: a localização do Cloud KMS do conjunto de chaves.

    Consulte a KeyRing.create documentação da API para mais informações.

O que se segue?