Se usó la API de Cloud Translation para traducir esta página.

Solicitar un certificado

En esta página, se describe cómo crear una solicitud de certificado en Certificate Authority Service.

Puedes solicitar un certificado con los siguientes métodos:

Genera tu propia clave privada o pública y envía una solicitud de firma de certificado (CSR).
Usa una clave privada o pública generada automáticamente por el servicio de CA.
Usar una clave existente de Cloud Key Management Service (Cloud KMS)

Antes de comenzar

Prepara tu entorno para CA Service.
Si deseas obtener los permisos que necesitas para emitir certificados, pídele a tu administrador para que te otorgue el solicitante del certificado del servicio de CA (roles/privateca.certificateRequester) el Administrador de certificados del servicio de CA (roles/privateca.certificateManager) IAM en el área de la seguridad en la nube.

Obtén más información sobre los roles de IAM predefinidos CA Service, consulta Control de acceso con la IAM.

Para obtener información sobre cómo otorgar un rol de IAM a un principal, consulta Otorga un solo rol.

Solicita un certificado mediante una CSR

Para obtener un certificado, debes generar una CSR y usarla para solicitarlo.

Genera la CSR

Para obtener instrucciones detalladas sobre cómo generar una CSR con OpenSSL, consulta How to generate CSR with OpenSSL. También puedes usar el siguiente archivo de configuración de muestra como referencia cuando generes tu CSR.

Para usar el archivo de configuración de muestra, sigue estos pasos:

Crea un archivo de configuración llamado csr.cnf con la siguiente configuración.
```
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 ejemplo genera una clave RSA de 2,048 bits (encriptada con una frase de contraseña) y una CSR correspondiente que contiene lo siguiente:
- el atributo commonName en el DN del sujeto
- la extensión subjectAlternativeName
- la extensión keyUsage (marcada como crítica)
- la extensión extendedKeyUsage
Modifica los parámetros según sea necesario. Para usar el formato de archivo de configuración x509v3_config con el fin de definir extensiones para certificados X.509 y CSR, consulta la documentación de OpenSSL.
Ejecuta el siguiente comando openssl para generar una CSR y una clave privada correspondiente:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
Este comando genera los siguientes archivos:
- csr.pem: Tu CSR, lista para enviarse a una AC
- key.pem: Es tu clave privada, que debes mantener protegida.
Usa el archivo csr.pem en tu solicitud de certificado.

Envía la solicitud de certificado con la CSR

Para solicitar un certificado mediante CSR, sigue estos pasos:

Console

Ve a la página Certificate Authority Service en la consola de Google Cloud.

Ir a Certificate Authority Service
Haz clic en Solicitar certificado.
Selecciona una región. La región debe ser la misma que la del grupo de AC. que pretendes usar.
Selecciona un grupo de AC.
Opcional: Selecciona una AC específica del grupo de AC. Ten en cuenta que, cuando eliges una AC específica para la emisión de certificados, creas una dependencia en esa AC, lo que dificulta la rotación de AC.
Opcional: Elige una plantilla de certificado. Si usas una plantilla de certificado, asegúrate de que las políticas de la plantilla de certificado no entren en conflicto con las políticas del grupo de AC seleccionado.
Haz clic en Provide Certificate Signing Request (CSR) y, luego, en Next. Se mostrarán los detalles del certificado.
Opcional: Para reemplazar el nombre del certificado generado automáticamente, ingresa el nombre personalizado en el campo Nombre del certificado. Después del certificado, no puedes borrarlo ni volver a usarlo de la fuente de datos.
Opcional: Para elegir un período de validez personalizado para el certificado, ingresa el valor del campo Válido para.
Copia y pega tu CSR en el cuadro Certificate CSR. Si quieres Para subir un archivo que contenga la CSR, haz clic en Browse y, luego, elige tu archivo.
Haz clic en Generar certificado.

Descarga el certificado firmado

Para ver el certificado generado, haz clic en Ver certificado y, luego, en Ver.
Para copiar el certificado, haz clic en . Para descargar el certificado en forma de archivo .crt, haz clic en Descargar certificado.
Opcional: Para descargar la cadena de certificados, haz clic en Descarga la cadena de certificados.

gcloud

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

Reemplaza lo siguiente:

CERT_ID: Es el identificador único del certificado.
POOL_ID: Es el nombre del grupo de AC.
CSR_FILENAME: Es el archivo que almacena la CSR codificada en PEM.

La marca --validity define la duración de la validez del certificado. Es una marca opcional cuyo valor predeterminado es de 30 días.

Para obtener más información sobre el comando gcloud privateca certificates create, consulta gcloud privatecacertificate 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 de REST

Genera una solicitud de firma de certificado (CSR) con el método que prefieras, como openssl.

El siguiente es un CSR de muestra codificado para JSON.

Solicita un certificado.

Método HTTP y URL:
```
POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID
```
Cuerpo JSON de la solicitud:
```
{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}
```
Para enviar tu solicitud, expande una de estas opciones:
curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:
```
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)

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:
```
$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
```
Deberías recibir una respuesta JSON similar a la que se muestra a continuación:
```
{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}
```
Precaución: Te recomendamos que no emitas certificados de entidad final desde una AC raíz. Para obtener información sobre la creación de AC subordinadas, consulta Crea AC.

Solicita un certificado con una clave generada automáticamente

Console

Puedes usar la consola de Google Cloud para generar certificados TLS de cliente o servidor.

Ve a la página Certificate Authority Service (Servicio de autoridad certificadora) en la consola de Google Cloud.

Ir a Certificate Authority Service
Haz clic en Solicitar certificado.
Selecciona una región. La región debe ser la misma que la del grupo de AC. que pretendes usar.
Selecciona un grupo de AC.
Haz clic en Ingresar los detalles manualmente. Se mostrarán los detalles del certificado.
Opcional: Reemplaza el Nombre del certificado generado automáticamente por un nombre personalizado que sea único.
Opcional: Para elegir un período de validez personalizado para el certificado, ingresa el valor en el campo Válido para.

Agregar un nombre de dominio

En Agregar nombre de dominio, ingresa un nombre de dominio en el campo Nombre de dominio 1.
Opcional: Si deseas agregar más de un nombre de dominio, haz clic en Agregar elemento y, luego, ingresa otro nombre de dominio en el campo Nombre de dominio 2.

Uso extendido de la clave

Opcional: En Uso de claves extendidas, selecciona una de las siguientes opciones según tu caso de uso:
- TLS de cliente: Estos certificados te permiten autenticar la identidad de un solicitante.
- TLS del servidor: Estos certificados te permiten autenticar la identidad de un servidor.
Haz clic en Siguiente.

Configura el tamaño de la clave y el algoritmo

Opcional: En Configura el tamaño de la clave y el algoritmo, selecciona la opción de firma. tamaño de clave y algoritmo de la lista. Si omites este paso, Se usa una clave RSASSA-PSS de 2048 bits con un resumen SHA 256. Información para seleccionar una clave de firma y un algoritmo, consulta Elige un algoritmo de clave.
Haz clic en Generate certificate.

Descarga el certificado firmado

Para ver el certificado generado, haz clic en Ver certificado y, luego, en Ver.
Opcional: Para descargar la cadena de certificados con codificación PEM, haz clic en Descarga la cadena de certificados.
Opcional: Para descargar la clave privada con codificación PEM asociada, haz clic en Descarga la clave privada.

Importante: No puedes recuperar esta clave después de salir de esta página. Esta clave es sensible. Te recomendamos que protejas la clave en una ubicación segura.
Importante: Si usas un grupo de AC de DevOps, esta es la única vez que puedes descargar el certificado creado. El servicio de AC no almacena el contenido del certificado después de esta pantalla.

gcloud

Para usar la función de clave generada automáticamente, debes instalar Python Cryptographic Authority (PyCA) del Reino Unido. Para obtener instrucciones sobre cómo instalar la biblioteca de criptografía de Pyca, consulta Incluye la biblioteca de criptografía de Pyca.

Para crear un certificado, usa el siguiente 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"

Reemplaza lo siguiente:

POOL_ID: Es el nombre del grupo de AC.
KEY_FILENAME: Es la ruta de acceso en la que se generan de claves privadas.
CERT_FILENAME: Es la ruta de PEM en la que se codifica archivo de la cadena de certificados. La cadena de certificados se ordena de la entidad final a la raíz.
DNS_NAME: Uno o más nombres alternativos de entidad (SAN) de DNS separados por comas.
CERTIFICATE_PROFILE: El identificador único de el perfil del certificado. Por ejemplo, usa leaf_server_tls para TLS del servidor de entidad final.

El comando gcloud menciona las siguientes marcas:

--generate-key: Genera una nueva clave privada RSA-2048 en tu máquina.

También puedes usar cualquier combinación de las siguientes marcas:

--dns-san: Te permite pasar una o más SAN de DNS separadas por comas.
--ip-san: Te permite pasar una o más SAN de IP separadas por comas.
--uri-san: Te permite pasar uno o más SAN de URI separados por comas.
--subject: Te permite pasar un nombre X.501 del sujeto del certificado.

Para obtener más información sobre el comando gcloud privateca certificates create, consulta gcloud privateca certificates create.

Go

Para autenticarte en el servicio de AC, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

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)

Solicita un certificado con una clave de Cloud KMS existente

Solo puedes usar Google Cloud CLI para solicitar certificados con una clave de Cloud KMS.

gcloud

Para usar una clave de Cloud KMS para crear un certificado TLS de servidor de entidad final, ejecuta el siguiente 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"

Reemplaza lo siguiente:

POOL_ID: Es el nombre del grupo de AC.
PROJECT_ID: El ID del proyecto
LOCATION_ID: Es la ubicación del llavero de claves.
KEY_RING: Es el nombre del llavero de claves en el que se encuentra la clave.
KEY: El nombre de la clave.
KEY_VERSION: Es la versión de la clave.
CERT_FILENAME: Es la ruta de acceso del archivo PEM con codificación de la cadena de certificados. El archivo de cadena de certificados se ordena desde la entidad final a la raíz.
DNS_NAME: SAN de DNS separados por comas.

Emite un certificado de una AC específica en un grupo de AC

En esta sección, se describe cómo emitir certificados de una AC específica en un grupo de AC.

Console

Ve a la página Certificate Authority Service en la consola de Google Cloud.

Ir a Certificate Authority Service
Haz clic en Solicitar certificado.
Selecciona una región. La región debe ser la misma que la del grupo de AC. que pretendes usar.
Selecciona un grupo de AC.
Para elegir una AC, haz clic en Usar una AC específica de este grupo de AC y, luego, selecciona una AC de la lista.
Selecciona otros parámetros como lo hiciste en la sección Solicita un certificado con una clave generada automáticamente o en la sección Solicita un certificado con una CSR.

gcloud

Para segmentar una AC específica en el grupo de AC para la emisión de certificados, agrega la marca --ca con el CA_ID de la AC que debe emitir el 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
}

Solicita un certificado en modo de validación

Si solicitas un certificado en modo de validación, se crea un certificado de prueba sin firmar. Este certificado de prueba no está codificado con PEM y no genera cargos. Si bien no puedes descargar el certificado, la descripción hipotética del certificado te permite confirmar que puedes emitir correctamente un certificado firmado con la firma de tu parámetros.

Para solicitar un certificado en modo de validación, sigue estos pasos:

Console

Ve a la página Certificate Authority Service (Servicio de autoridad certificadora) en la consola de Google Cloud.

Ir a Certificate Authority Service
Haz clic en Solicitar certificado.
Selecciona Usar el modo de validación para obtener una descripción hipotética de certificado en lugar de un certificado firmado.
Siga los mismos pasos que para solicitar un certificado firmado.

¿Qué sigue?

Obtén más información sobre los perfiles de certificado.
Obtén información para revocar certificados.
Obtén más información sobre cómo ordenar y filtrar certificados.
Obtén información para administrar certificados con Google Cloud CLI.

Solicitar un certificado

Antes de comenzar

Solicita un certificado mediante una CSR

Genera la CSR

Envía la solicitud de certificado con la CSR

Console

gcloud

Terraform

API de REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Solicita un certificado con una clave generada automáticamente

Console

gcloud

Go

Java

Python

Solicita un certificado con una clave de Cloud KMS existente

gcloud

Emite un certificado de una AC específica en un grupo de AC

Console

gcloud

Terraform

Solicita un certificado en modo de validación

Console

¿Qué sigue?