Esta página foi traduzida pela API Cloud Translation.

Solicitar um certificado

Nesta página, descrevemos como criar uma solicitação de certificado no Certificate Authority Service.

É possível solicitar um certificado usando os métodos a seguir:

gerar sua própria chave privada ou pública e enviar uma solicitação de assinatura de certificado (CSR, na sigla em inglês).
Use uma chave privada ou pública gerada automaticamente pelo CA Service.
Usar uma chave atual do Cloud Key Management Service (Cloud KMS).

Antes de começar

Prepare seu ambiente para o CA Service.
Para receber as permissões necessárias para emitir certificados, peça ao administrador para conceder a você o papel de solicitante de certificado de serviço de CA (roles/privateca.certificateRequester) ou de gerenciador de certificados de serviço de CA (roles/privateca.certificateManager) do IAM.

Para mais informações sobre os papéis predefinidos do IAM para o serviço de CA, consulte Controle de acesso com o IAM.

Para informações sobre como conceder um papel do IAM a um principal, consulte Conceder um único papel.

Solicitar certificado usando uma CSR

Para obter um certificado, gere uma CSR, que será usada para solicitar o certificado.

Gerar a CSR

Para instruções detalhadas sobre como gerar uma CSR usando o OpenSSL, consulte Como gerar uma CSR com o OpenSSL. Você também pode usar o arquivo de configuração de exemplo a seguir como referência ao gerar a CSR.

Para usar o arquivo de configuração de amostra, siga estas etapas:

Crie um arquivo de configuração chamado csr.cnf usando a configuração a seguir.
```
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
```
Este exemplo gera uma Chave RSA de 2.048 bits (senha criptografada) e um CSR correspondente contendo o seguinte:
- o atributo commonName no DN do assunto
- a extensão subjectAlternativeName
- a extensão keyUsage (marcada como crítica)
- a extensão extendedKeyUsage
Modifique os parâmetros conforme necessário. Se quiser usar o formato de arquivo de configuração x509v3_config para definir extensões para certificados X.509 e CSRs, consulte a documentação do OpenSSL (link em inglês).
Execute o seguinte comando openssl para gerar uma CSR e uma chave privada correspondente:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
Esse comando gera os seguintes arquivos:
- csr.pem: sua CSR, pronta para ser enviada a uma AC
- key.pem: sua chave privada, que você precisa manter em segurança.
Use o arquivo csr.pem na solicitação de certificado.

Enviar a solicitação de certificado usando a CSR

Para solicitar um certificado usando a CSR, siga estas etapas:

Console

Acesse a página Certificate Authority Service no console do Google Cloud.

Acessar o Certificate Authority Service (em inglês)
Clique em Solicitar um certificado.
Selecione uma região. A região precisa ser a mesma do pool de ACs que você pretende usar.
Selecione um pool de ACs.
Opcional: selecione uma AC específica do pool de ACs. Ao escolher uma AC específica para a emissão de certificados, você cria uma dependência nela, dificultando a rotação de ACs.
Opcional: escolha um modelo de certificado. Se você usar um modelo de certificado, verifique se as políticas dele não entram em conflito com as políticas do pool de ACs selecionadas.
Clique em Fornecer solicitação de assinatura de certificado (CSR) e em Avançar. Os detalhes do certificado serão exibidos.
Opcional: para substituir o nome do certificado gerado automaticamente, insira o nome personalizado no campo Nome do certificado. Após a criação do certificado, não é possível excluir ou reutilizar o nome do certificado.
Opcional: para escolher um período de validade personalizado para o certificado, insira o valor no campo Válido para.
Copie e cole a CSR na caixa Certificate CSR. Para fazer upload de um arquivo contendo a CSR, clique em Procurar e, em seguida, escolha seu arquivo.
Clique em Gerar certificado.

Fazer o download do certificado assinado

Para acessar o certificado gerado, clique em Ver certificado e em Ver.
Para copiar o certificado, clique em . Para fazer o download do certificado na forma de um arquivo .crt, clique em Fazer o download do certificado.
Opcional: para fazer o download da cadeia de certificados, clique em Fazer o download da cadeia de certificados.

gcloud

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

Substitua:

CERT_ID: o identificador exclusivo do certificado.
POOL_ID: o nome do pool de ACs.
CSR_FILENAME: o arquivo que armazena a CSR codificada em PEM.

A sinalização --validity define o período de validade do certificado. É uma sinalização opcional cujo valor padrão é 30 dias.

Para mais informações sobre o comando gcloud privateca certificates create, consulte gcloud privateca credentials 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

Gere uma solicitação de assinatura de certificado (CSR, na sigla em inglês) usando seu método preferido, como openssl.

Veja a seguir um exemplo de CSR codificado para JSON.

Solicite um certificado.

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login , ou usando o Cloud Shell, que automaticamente conecta você à CLI gcloud . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID"

PowerShell (Windows)

Observação: O comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

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

Solicitar certificado usando uma chave gerada automaticamente

Console

Use o console do Google Cloud para gerar certificados TLS de cliente ou servidor.

Acesse a página Certificate Authority Service no console do Google Cloud.

Acessar o Certificate Authority Service (em inglês)
Clique em Solicitar um certificado.
Selecione uma região. A região precisa ser a mesma do pool de ACs que você pretende usar.
Selecione um pool de ACs.
Clique em Inserir detalhes manualmente. Os detalhes do certificado serão exibidos.
Opcional: substitua o Nome do certificado gerado automaticamente por um nome personalizado exclusivo.
Opcional: para escolher um período de validade personalizado para o certificado, insira o valor no campo Válido para.

Adicionar nome de domínio

Em Adicionar nome de domínio, digite um nome de domínio no campo Nome de domínio 1.
Opcional: para adicionar mais de um nome de domínio, clique em Adicionar item e digite outro nome de domínio no campo Nome de domínio 2.

Uso estendido de chave

Opcional: em Uso estendido de chave, selecione entre as seguintes opções com base no seu caso de uso:
- TLS do cliente: esses certificados permitem autenticar a identidade de um solicitante.
- TLS do servidor: esses certificados permitem autenticar a identidade de um servidor.
Clique em Próxima.

Configurar o tamanho e o algoritmo da chave

Opcional: em Configurar o tamanho e o algoritmo da chave, selecione o tamanho e o algoritmo da chave de assinatura na lista. Se você pular esta etapa, a chave RSA de 2.048 bits com um resumo SHA 256 será usada. Para informações sobre como selecionar uma chave de assinatura e um algoritmo, consulte Escolher um algoritmo de chave.
Clique em Gerar certificado.

Fazer o download do certificado assinado

Para acessar o certificado gerado, clique em Ver certificado e em Ver.
Opcional: para fazer o download da cadeia de certificados codificadas por PEM, clique em Fazer o download da cadeia de certificados.
Opcional: para fazer o download da chave privada codificada em PEM associada, clique em Fazer o download da chave privada.

Importante :não é possível recuperar a chave depois de sair da página. Essa chave é confidencial. Recomendamos proteger a chave em um local seguro.
Importante: se você estiver usando um pool de CAs de DevOps, essa será a única vez em que será possível fazer o download do certificado criado. O CA Service não armazena o conteúdo do certificado depois dessa tela.

gcloud

Para usar o recurso de chave gerada automaticamente, instale a biblioteca da Autoridade criptográfica do Python (PyCA). Para instruções sobre como instalar a biblioteca de criptografia Pyca, consulte Como incluir a biblioteca de criptografia Pyca.

Para criar um certificado, use o seguinte 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"

Substitua:

POOL_ID: o nome do pool de ACs.
KEY_FILENAME: o caminho em que o arquivo de chave privada gerado precisa ser gravado.
CERT_FILENAME: o caminho em que o arquivo de cadeia de certificados codificado por PEM precisa ser gravado. A cadeia de certificados é ordenada da entidade final para a raiz.
DNS_NAME: um ou mais nomes alternativos de assunto (SANs, na sigla em inglês) do DNS separados por vírgulas.
CERTIFICATE_PROFILE: o identificador exclusivo do perfil de certificado. Por exemplo, use leaf_server_tls para o TLS do servidor da entidade final.

O comando gcloud menciona as seguintes sinalizações:

--generate-key: gera uma nova chave privada RSA-2048 na sua máquina.

Também é possível usar qualquer combinação das seguintes sinalizações:

--dns-san: permite transmitir uma ou mais SANs DNS separadas por vírgulas.
--ip-san: permite transmitir uma ou mais SANs IP separadas por vírgulas.
--uri-san: permite transmitir uma ou mais SANs URI separadas por vírgulas.
--subject: permite transmitir um nome X.501 do assunto do certificado.

Para mais informações sobre o comando gcloud privateca certificates create, consulte gcloud privateca credentials create.

Go

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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)

Solicitar certificado usando uma chave do Cloud KMS

Só é possível usar a Google Cloud CLI para solicitar certificados com uma chave do Cloud KMS.

gcloud

Para usar uma chave do Cloud KMS e criar um certificado TLS do servidor de entidade final, execute o seguinte 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"

Substitua:

POOL_ID: o nome do pool de ACs.
PROJECT_ID: o ID do projeto.
LOCATION_ID: a localização do keyring.
KEY_RING: o nome do keyring em que a chave está localizada.
KEY: o nome da chave.
KEY_VERSION: a versão da chave.
CERT_FILENAME: o caminho do arquivo de cadeia de certificados codificado em PEM. O arquivo da cadeia de certificados é ordenado da entidade final para a raiz.
DNS_NAME: SANs DNS separadas por vírgulas.

Emitir um certificado de uma AC específica em um pool de ACs

Nesta seção, descrevemos como emitir certificados de uma AC específica em um pool de ACs.

Console

Acesse a página Certificate Authority Service no console do Google Cloud.

Acessar o Certificate Authority Service (em inglês)
Clique em Solicitar um certificado.
Selecione uma região. A região precisa ser a mesma do pool de ACs que você pretende usar.
Selecione um pool de ACs.
Para escolher uma AC, clique em Usar uma AC específica deste pool de ACs e selecione uma AC da lista.
Selecione outros parâmetros, como você fez na seção Solicitar certificado usando uma chave gerada automaticamente ou na seção Solicitar certificado usando uma CSR.

gcloud

Para direcionar uma AC específica no pool de ACs para emissão de certificados, adicione a flag --ca com o CA_ID da AC que precisa emitir o certificado.

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
}

Solicitar um certificado no modo de validação

Solicitar um certificado no modo de validação cria um certificado de teste não assinado. Este certificado de teste não é codificado no formato PEM e não gera cobranças. Não é possível fazer o download do certificado, mas a descrição hipotética dele permite confirmar que você consegue emitir um certificado assinado com os parâmetros escolhidos.

Para solicitar um certificado no modo de validação, siga estas etapas:

Console

Acesse a página Certificate Authority Service no console do Google Cloud.

Acessar o Certificate Authority Service (em inglês)
Clique em Solicitar um certificado.
Selecione Usar o modo de validação para uma descrição de certificado hipotético em vez de um certificado assinado.
Siga as mesmas etapas para solicitar um certificado assinado.

A seguir

Saiba mais sobre perfis de certificado.
Saiba como revogar certificados.
Saiba como classificar e filtrar certificados.
Saiba como gerenciar certificados usando a Google Cloud CLI.