Richiedi un certificato

Questa pagina descrive come creare una richiesta di certificato in Certificate Authority Service.

Puoi richiedere un certificato utilizzando i seguenti metodi:

  1. Genera la tua chiave privata o pubblica e invia una richiesta di firma del certificato (CSR).
  2. Utilizza una chiave privata o pubblica generata automaticamente dal servizio CA.
  3. Utilizza una chiave Cloud Key Management Service (Cloud KMS) esistente.

Prima di iniziare

  1. Prepara l'ambiente per il servizio CA.

  2. Per ottenere le autorizzazioni necessarie per emettere certificati, chiedi all'amministratore di concederti il ruolo IAM CA Service Certificate Requester (roles/privateca.certificateRequester) o CA Service Certificate Manager (roles/privateca.certificateManager).

    Per ulteriori informazioni sui ruoli IAM predefiniti per il servizio CA, consulta Controllo dell'accesso con IAM.

    Per informazioni su come concedere un ruolo IAM a un'entità, consulta Concedere un singolo ruolo.

Richiedere un certificato utilizzando una CSR

Per ottenere un certificato, genera una CSR, che poi utilizzi per richiederlo.

Genera la CSR

Per istruzioni dettagliate su come generare una CSR utilizzando OpenSSL, consulta Come generare una CSR con OpenSSL. Puoi anche utilizzare il seguente file di configurazione di esempio come riferimento per la generazione del CSR.

Per utilizzare il file di configurazione di esempio:

  1. Crea un file di configurazione denominato csr.cnf utilizzando la seguente configurazione.

    cat << EOF > csr.cnf
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
prompt = no

[req_distinguished_name]
CN = example.com

[v3_req]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com
DNS.2 = www.example.com
EOF

    Questo esempio genera una chiave RSA a 2048 bit (criptata con passphrase) e una CSR corrispondente contenente quanto segue:

    • l'attributo commonName nel DN soggetto
    • l'estensione subjectAlternativeName
    • l'estensione keyUsage (contrassegnata come critica)
    • l'estensione extendedKeyUsage

    Modifica i parametri in base alle esigenze. Per utilizzare il formato del file di configurazione x509v3_config per definire le estensioni per i certificati X.509 e le CSR, consulta la documentazione di OpenSSL.

  2. Esegui il seguente comando openssl per generare una CSR e una chiave privata corrispondente:

    openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf

    Questo comando genera i seguenti file:

    • csr.pem: la CSR, pronta per essere inviata a una CA
    • key.pem: la tua chiave privata, che devi conservare al sicuro

    Utilizza il file csr.pem nella richiesta del certificato.

Invia la richiesta di certificato utilizzando la CSR

Per richiedere un certificato utilizzando la CSR:

Console

  1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

    Vai a Certificate Authority Service

  2. Fai clic su Richiedi un certificato.

  3. Seleziona una regione. La regione deve essere la stessa del pool di CA che intendi utilizzare.

  4. Seleziona un pool di CA.

  5. (Facoltativo) Seleziona una CA specifica dal pool di CA. Tieni presente che, quando scegli una CA specifica per l'emissione dei certificati, crei una dipendenza da questa CA, rendendo più difficile la rotazione delle CA.

  6. (Facoltativo) Scegli un modello di certificato. Se utilizzi un modello di certificato, assicurati che i relativi criteri non entrino in conflitto con quelli del pool di CA selezionato.

  7. Fai clic su Fornisci una richiesta di firma del certificato (CSR) e poi su Avanti. Vengono visualizzati i dettagli del certificato.

  8. (Facoltativo) Per sovrascrivere il nome del certificato generato automaticamente, inserisci il nome personalizzato nel campo Nome certificato. Una volta creato il nome del certificato, non puoi eliminarlo né riutilizzarlo.

  9. (Facoltativo) Per scegliere un periodo di validità personalizzato per il certificato, inserisci il valore nel campo Valido per.

  10. Copia e incolla il CSR nella casella CSR del certificato. Se vuoi caricare un file contenente il CSR, fai clic su Sfoglia e poi scegli il file.

  11. Fai clic su Genera certificato.

Scarica il certificato firmato

  1. Per visualizzare il certificato generato, fai clic su Visualizza certificato e poi su Visualizza.
  2. Per copiare il certificato, fai clic su . Per scaricare il certificato sotto forma di file .crt, fai clic su Scarica certificato.
  3. (Facoltativo) Per scaricare la catena di certificati, fai clic su Scarica catena di certificati.

gcloud

gcloud privateca certificates create CERT_ID \
     --issuer-pool POOL_ID \
     --csr CSR_FILENAME \
     --cert-output-file CERT_FILENAME \
     --validity "P30D"

Sostituisci quanto segue:

  • CERT_ID: l'identificatore univoco del certificato.
  • POOL_ID: il nome del pool di CA.
  • CSR_FILENAME: il file che memorizza il CSR con codifica PEM.

Il flag --validity definisce la durata di validità del certificato. Si tratta di un flag facoltativo il cui valore predefinito è 30 giorni.

Per ulteriori informazioni sul comando gcloud privateca certificates create, consulta gcloud privateca certificates create.

Terraform

resource "google_privateca_certificate_authority" "test_ca" {
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool                  = "my-pool"
  location              = "us-central1"
  certificate_authority = google_privateca_certificate_authority.test_ca.certificate_authority_id
  lifetime              = "860s"
  name                  = "my-certificate"
  pem_csr               = tls_cert_request.example.cert_request_pem
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

resource "tls_cert_request" "example" {
  private_key_pem = tls_private_key.example.private_key_pem

  subject {
    common_name  = "example.com"
    organization = "ACME Examples, Inc"
  }
}

API REST

  1. Genera una richiesta di firma del certificato (CSR) utilizzando il metodo che preferisci, ad esempio openssl.

    Di seguito è riportato un CSR di esempio codificato per JSON.

    -----BEGIN CERTIFICATE REQUEST-----\nMIIChTCCAW0CAQAwQDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ8wDQYDVQQK\nDAZKb29uaXgxEzARBgNVBAMMCmpvb25peC5uZXQwggEiMA0GCSqGSIb3DQEBAQUA\nA4IBDwAwggEKAoIBAQCnyy+5vcRQUBPqAse3ojmWjyUvhcJK6eLRXpp0teEUF5kg\nHb2ov8gYXb9sSim5fnvs09dGYDKibSrL4Siy7lA/NzMzWtKwyQQeLIQq/cLUJVcd\ndItJ0VRcqr+UPkTCii2vrdcocNDChHM1J8chDdl6DkpYieSTqZwlPcWlQBGAINmT\nT3Q0ZarIVM5l74j13WPuToGrhbVOIZXWxWqJjlHbBA8B/VKtSRCzM1qG60y8Pu2f\n6c78Dfg8+CGRzGwnz8aFS0Yf9czT9luNHSadS/RHjvE9FPZCsinz+6mJlXRcphi1\nKaHsDbstUAhse1h5E9Biyr9SFYRHxY7qRv9aSJ/dAgMBAAGgADANBgkqhkiG9w0B\nAQsFAAOCAQEAZz+I9ff1Rf3lTewXRUpA7nr5HVO1ojCR93Pf27tI/hvNH7z7GwnS\noScoJlClxeRqABOCnfmVoRChullb/KmER4BZ/lF0GQpEtbqbjgjkEDpVlBKCb0+L\nHE9psplIz6H9nfFS3Ouoiodk902vrMEh0LyDYNQuqFoyCZuuepUlK3NmtmkexlgT\n0pJg/5FV0iaQ+GiFXSZhTC3drfiM/wDnXGiqpbW9WmebSij5O+3BNYXKBUgqmT3r\nbryFydNq4qSOIbnN/MNb4UoKno3ve7mnGk9lIDf9UMPvhl+bT7C3OLQLGadJroME\npYnKLoZUvRwEdtZpbNL9QhCAm2QiJ6w+6g==\n-----END CERTIFICATE REQUEST-----

  2. Richiedi un certificato.

    Metodo HTTP e URL: 

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID

    Corpo JSON della richiesta: 

    {
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

    {
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}

Richiedi un certificato utilizzando una chiave generata automaticamente

Console

Puoi utilizzare la console Google Cloud per generare certificati TLS client o server.

  1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

    Vai a Certificate Authority Service

  2. Fai clic su Richiedi un certificato.

  3. Seleziona una regione. La regione deve essere la stessa del pool di CA che intendi utilizzare.

  4. Seleziona un pool di CA.

  5. Fai clic su Inserisci i dettagli manualmente. Vengono visualizzati i dettagli del certificato.

  6. (Facoltativo) Sostituisci il nome del certificato generato automaticamente con un nome personalizzato univoco.

  7. (Facoltativo) Per scegliere un periodo di validità personalizzato per il certificato, inserisci il valore nel campo Valido per.

Aggiungere il nome di dominio

  1. In Aggiungi nome di dominio, inserisci un nome di dominio nel campo Nome di dominio 1.
  2. (Facoltativo) Se vuoi aggiungere più di un nome di dominio, fai clic su Aggiungi elemento e inserisci un altro nome di dominio nel campo Nome di dominio 2.

Utilizzo esteso della chiave

  1. (Facoltativo) In Utilizzo esteso della chiave, scegli tra le seguenti opzioni in base al tuo caso d'uso:

    • TLS client: questi certificati ti consentono di autenticare l'identità di un richiedente.
    • TLS del server: questi certificati ti consentono di autenticare l'identità di un server.

  2. Fai clic su Avanti.

Configura le dimensioni e l'algoritmo della chiave

  1. (Facoltativo) In Configura dimensioni e algoritmo della chiave, seleziona le dimensioni e l'algoritmo della chiave di firma dall'elenco. Se salti questo passaggio, viene utilizzata una chiave RSASSA-PSS a 2048 bit con un digest SHA 256. Per informazioni sulla selezione di un algoritmo e di una chiave di firma, consulta Scegliere un algoritmo chiave.
  2. Fai clic su Genera certificato.

Scarica il certificato firmato

  1. Per visualizzare il certificato generato, fai clic su Visualizza certificato e poi su Visualizza.
  2. (Facoltativo) Per scaricare la catena di certificati con codifica PEM, fai clic su Scarica catena di certificati.

  3. (Facoltativo) Per scaricare la chiave privata con codifica PEM associata, fai clic su Scarica chiave privata.

gcloud

Per utilizzare la funzionalità della chiave generata automaticamente, devi installare la libreria Python Cryptographic Authority (PyCA). Per istruzioni sull'installazione della libreria di crittografia Pyca, consulta Aggiunta della libreria di crittografia Pyca.

Per creare un certificato, utilizza il seguente comando gcloud:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "CERTIFICATE_PROFILE"

Sostituisci quanto segue:

  • POOL_ID: il nome del pool di CA.
  • KEY_FILENAME: il percorso in cui deve essere scritto il file della chiave privata generata.
  • CERT_FILENAME: il percorso in cui deve essere scritto il file della catena di certificati con codifica PEM. La catena di certificati è disposta dall'entità finale a quella radice.
  • DNS_NAME: uno o più nomi DNS alternativi dell'oggetto (SAN) separati da virgole.
  • CERTIFICATE_PROFILE: l'identificatore univoco del profilo del certificato. Ad esempio, utilizza leaf_server_tls per TLS del server entità finale.

Il comando gcloud menziona i seguenti flag:

  • --generate-key: genera una nuova chiave privata RSA-2048 sulla tua macchina.

Puoi anche utilizzare una qualsiasi combinazione dei seguenti flag:

  • --dns-san: consente di passare uno o più SAN DNS separati da virgole.
  • --ip-san: consente di passare uno o più SAN IP separati da virgola.
  • --uri-san: consente di passare uno o più URI SAN separati da virgole.
  • --subject: consente di passare un nome X.501 dell'oggetto del certificato.

Per ulteriori informazioni sul comando gcloud privateca certificates create, consulta gcloud privateca certificates create.

Vai

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
// The key used to sign the certificate is created by the Cloud KMS.
func createCertificate(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	certId string,
	commonName string,
	domainName string,
	certDuration int64,
	publicKeyBytes []byte) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate authority exists.
	// caId := "ca-id"					// The name of the certificate authority which issues the certificate.
	// certId := "certificate"			// A unique name for the certificate.
	// commonName := "cert-name"		// A common name for the certificate.
	// domainName := "cert.example.com"	// Fully qualified domain name for the certificate.
	// certDuration := int64(31536000)	// The validity of the certificate in seconds.
	// publicKeyBytes 					// The public key used in signing the certificates.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	// Set the Public Key and its format.
	publicKey := &privatecapb.PublicKey{
		Key:    publicKeyBytes,
		Format: privatecapb.PublicKey_PEM,
	}

	// Set Certificate subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName: commonName,
		},
		SubjectAltName: &privatecapb.SubjectAltNames{
			DnsNames: []string{domainName},
		},
	}

	// Set the X.509 fields required for the certificate.
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				DigitalSignature: true,
				KeyEncipherment:  true,
			},
			ExtendedKeyUsage: &privatecapb.KeyUsage_ExtendedKeyUsageOptions{
				ServerAuth: true,
				ClientAuth: true,
			},
		},
	}

	// Set certificate settings.
	cert := &privatecapb.Certificate{
		CertificateConfig: &privatecapb.Certificate_Config{
			Config: &privatecapb.CertificateConfig{
				PublicKey:     publicKey,
				SubjectConfig: subjectConfig,
				X509Config:    x509Parameters,
			},
		},
		Lifetime: &durationpb.Duration{
			Seconds: certDuration,
		},
	}

	fullCaPoolName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the CreateCertificateRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateRequest.
	req := &privatecapb.CreateCertificateRequest{
		Parent:                        fullCaPoolName,
		CertificateId:                 certId,
		Certificate:                   cert,
		IssuingCertificateAuthorityId: caId,
	}

	_, err = caClient.CreateCertificate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCertificate failed: %w", err)
	}

	fmt.Fprintf(w, "Certificate %s created", certId)

	return nil
}

Java

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.ExtendedKeyUsageOptions;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.PublicKey;
import com.google.cloud.security.privateca.v1.PublicKey.KeyFormat;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.SubjectAltNames;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificate {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.

    // publicKeyBytes: Public key used in signing the certificates.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set a unique id for the CA pool.
    // certificateAuthorityName: The name of the certificate authority which issues the certificate.
    // certificateName: Set a unique name for the certificate.
    String project = "your-project-id";
    ByteString publicKeyBytes = ByteString.copyFrom(new byte[]{});
    String location = "ca-location";
    String poolId = "ca-poolId";
    String certificateAuthorityName = "certificate-authority-name";
    String certificateName = "certificate-name";

    createCertificate(
        project, location, poolId, certificateAuthorityName, certificateName, publicKeyBytes);
  }

  // Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
  // The public key used to sign the certificate can be generated using any crypto
  // library/framework.
  public static void createCertificate(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String certificateName,
      ByteString publicKeyBytes)
      throws InterruptedException, ExecutionException, 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 `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      // commonName: Enter a title for your certificate.
      // orgName: Provide the name of your company.
      // domainName: List the fully qualified domain name.
      // certificateLifetime: The validity of the certificate in seconds.
      String commonName = "commonname";
      String orgName = "orgname";
      String domainName = "dns.example.com";
      long certificateLifetime = 1000L;

      // Set the Public Key and its format.
      PublicKey publicKey =
          PublicKey.newBuilder().setKey(publicKeyBytes).setFormat(KeyFormat.PEM).build();

      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              // Set the common name and org name.
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              // Set the fully qualified domain name.
              .setSubjectAltName(SubjectAltNames.newBuilder().addDnsNames(domainName).build())
              .build();

      // Set the X.509 fields required for the certificate.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder()
                              .setDigitalSignature(true)
                              .setKeyEncipherment(true)
                              .setCertSign(true)
                              .build())
                      .setExtendedKeyUsage(
                          ExtendedKeyUsageOptions.newBuilder().setServerAuth(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).buildPartial())
              .build();

      // Create certificate.
      Certificate certificate =
          Certificate.newBuilder()
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setPublicKey(publicKey)
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              .setLifetime(Duration.newBuilder().setSeconds(certificateLifetime).build())
              .build();

      // Create the Certificate Request.
      CreateCertificateRequest certificateRequest =
          CreateCertificateRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateId(certificateName)
              .setCertificate(certificate)
              .setIssuingCertificateAuthorityId(certificateAuthorityName)
              .build();

      // Get the Certificate response.
      ApiFuture<Certificate> future =
          certificateAuthorityServiceClient
              .createCertificateCallable()
              .futureCall(certificateRequest);

      Certificate response = future.get();
      // Get the PEM encoded, signed X.509 certificate.
      System.out.println(response.getPemCertificate());
      // To verify the obtained certificate, use this intermediate chain list.
      System.out.println(response.getPemCertificateChainList());
    }
  }
}

Python

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Richiedi un certificato utilizzando una chiave Cloud KMS esistente

Puoi utilizzare Google Cloud CLI solo per richiedere certificati utilizzando una chiave Cloud KMS.

gcloud

Per utilizzare una chiave Cloud KMS per creare un certificato TLS del server dell'entità finale, esegui il seguente comando:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --kms-key-version projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING/cryptoKeys/KEY/cryptoKeyVersions/KEY_VERSION \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Sostituisci quanto segue:

  • POOL_ID: il nome del pool di CA.
  • PROJECT_ID: l'ID progetto.
  • LOCATION_ID: la posizione del keyring.
  • KEY_RING: il nome della chiave automatizzata in cui si trova la chiave.
  • KEY: il nome della chiave.
  • KEY_VERSION: la versione della chiave.
  • CERT_FILENAME: il percorso del file della catena di certificati con codifica PEM. Il file della catena di certificati è ordinato dall'entità finale alla radice.
  • DNS_NAME: SAN DNS separati da virgole.

Emettere un certificato da una CA specifica in un pool di CA

Questa sezione descrive come emettere certificati da una CA specifica in un pool di CA.

Console

  1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

    Vai a Certificate Authority Service

  2. Fai clic su Richiedi un certificato.

  3. Seleziona una regione. La regione deve essere la stessa del pool di CA che intendi utilizzare.

  4. Seleziona un pool di CA.

  5. Per scegliere una CA, fai clic su Utilizza una CA specifica di questo pool di CA e poi seleziona una CA dall'elenco.

  6. Seleziona altri parametri come nella sezione Richiedi certificato utilizzando una chiave generata automaticamente o nella sezione Richiedi certificato utilizzando una CSR.

gcloud

Per scegliere come target una CA specifica nel pool di CA per l'emissione del certificato, aggiungi il flag --ca con il CA_ID della CA che deve emettere il certificato.

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --ca CA_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Terraform

resource "google_privateca_certificate_authority" "authority" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-pool"
  certificate_authority_id = "my-sample-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          digital_signature = true
          cert_sign         = true
          crl_sign          = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool     = "my-pool"
  location = "us-central1"
  lifetime = "860s"
  name     = "my-sample-certificate"
  config {
    subject_config {
      subject {
        common_name         = "san1.example.com"
        country_code        = "us"
        organization        = "google"
        organizational_unit = "enterprise"
        locality            = "mountain view"
        province            = "california"
        street_address      = "1600 amphitheatre parkway"
        postal_code         = "94109"
      }
    }
    x509_config {
      ca_options {
        is_ca = false
      }
      key_usage {
        base_key_usage {
          crl_sign = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
    public_key {
      format = "PEM"
      key    = base64encode(data.tls_public_key.example.public_key_pem)
    }
  }
  // Certificates require an authority to exist in the pool, though they don't
  // need to be explicitly connected to it
  depends_on = [google_privateca_certificate_authority.authority]
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

data "tls_public_key" "example" {
  private_key_pem = tls_private_key.example.private_key_pem
}

Richiedere un certificato in modalità di convalida

La richiesta di un certificato in modalità di convalida crea un certificato di test non firmato. Questo certificato di prova non è codificato in PEM e non comporta costi. Anche se non puoi scaricare il certificato, la descrizione ipotetica del certificato consente di verificare che puoi emettere correttamente un certificato firmato con i parametri scelti.

Per richiedere un certificato in modalità di convalida:

Console

  1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

    Vai a Certificate Authority Service

  2. Fai clic su Richiedi un certificato.

  3. Seleziona Utilizza la modalità di convalida per una descrizione ipotetica del certificato anziché per un certificato firmato.

  4. Segui gli stessi passaggi che utilizzeresti per richiedere un certificato firmato.

Passaggi successivi