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 mediante 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.
A fin de obtener los permisos que necesitas para emitir certificados, pídele a tu administrador que te otorgue el rol de IAM de solicitante de certificado del servicio de CA (roles/privateca.certificateRequester) o Administrador de certificados del servicio de CA (roles/privateca.certificateManager).

Si deseas obtener más información sobre las funciones predefinidas de IAM para el servicio de CA, consulta Control de acceso con la IAM.

Para obtener más información sobre cómo otorgar un rol de IAM a una 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

Si quieres obtener instrucciones detalladas para generar una CSR con OpenSSL, consulta cómo generar una CSR con OpenSSL. También puedes usar el siguiente archivo de configuración de muestra como referencia cuando generas 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
```
En esta muestra, se genera una clave RSA de 2,048 bits (con frase de contraseña encriptada) y la 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. Si quieres usar el formato de archivo de configuración x509v3_config para definir extensiones para certificados X.509 y CSR, consulta la documentación de OpenSSL.
Ejecuta el siguiente comando de 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, listo 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 mediante CSR

Para solicitar un certificado mediante CSR, 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 una región. La región debe ser la misma que la del grupo de AC que quieres 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 ella, lo que dificulta la rotación de las 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 Proporcionar solicitud de firma de certificado (CSR) y, luego, en Siguiente. 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 de crear el certificado, no puedes borrar ni volver a usar el nombre del certificado.
Opcional: Si quieres elegir un período de validez personalizado para el certificado, ingresa el valor en el campo Válido para.
Copia y pega tu CSR en el cuadro Certificate CSR. Si deseas 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 Descargar 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 con codificación PEM.

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

Para obtener más información sobre el comando gcloud privateca certificates create, consulta gcloud privateca packages 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 tu método preferido, como openssl.

La siguiente es una CSR de ejemplo codificada 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 quieres usar.
Selecciona un grupo de AC.
Haz clic en Ingresar detalles de forma manual. Se mostrarán los detalles del certificado.
Opcional: Reemplaza el Certificate name (Nombre del certificado) generado automáticamente por un nombre personalizado que sea único.
Opcional: Si quieres elegir un período de validez personalizado para el certificado, ingresa el valor en el campo Válido para.

Agrega 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 extendido de claves, selecciona entre las siguientes opciones según tu caso de uso:
- TLS del 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 Configurar el tamaño de la clave y el algoritmo, selecciona el tamaño de la clave de firma y el algoritmo de la lista. Si omites este paso, se usa una clave RSASA-PSS de 2048 bits con un resumen SHA 256. Para obtener información sobre cómo seleccionar una clave de firma y un algoritmo, consulta Elige un algoritmo de clave.
Haz clic en Generar certificado.

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 Descargar cadena de certificados.
Opcional: Para descargar la clave privada con codificación PEM asociada, haz clic en Descargar clave privada.

Importante: No puedes recuperar esta clave después de salir de esta página. Esta clave es sensitive. Te recomendamos proteger 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 CA no almacena el contenido del certificado después de esta pantalla.

gcloud

Para usar la función de clave generada de forma automática, debes instalar la biblioteca de Python Authority (PyCA). 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 en la que se debe escribir el archivo de claves privadas generado.
CERT_FILENAME: Es la ruta de acceso en la que se debe escribir el archivo de cadena de certificados con codificación PEM. La cadena de certificados está ordenada desde la entidad final hasta la raíz.
DNS_NAME: Uno o más nombres de asunto de DNS (SAN) separados por comas.
CERTIFICATE_PROFILE: Es el identificador único del 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 clave privada RSA-2048 nueva en el equipo.

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

--dns-san: Te permite pasar uno o más SAN de DNS separados por comas.
--ip-san: Te permite pasar uno o más SAN de IP separados 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 asunto del certificado.

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

Go

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 (
	"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


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

Si quieres 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 de cadena de certificados con codificación PEM. El archivo de cadena de certificados está ordenado de entidad final a raíz.
DNS_NAME: SAN de DNS separados por comas.

Emitir 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 (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 quieres 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 Solicitar certificado mediante una clave generada automáticamente o Solicitar certificado mediante CSR.

gcloud

Si quieres orientarte a 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

La solicitud de un certificado en modo de validación crea un certificado de prueba sin firmar. Este certificado de prueba no está codificado con PEM y no genera ningún cargo. Si bien no puedes descargar el certificado, la descripción hipotética del certificado te permite confirmar que puedes emitir de forma correcta un certificado firmado con los parámetros que elegiste.

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 más información sobre cómo revocar certificados.
Obtén más información sobre cómo ordenar y filtrar certificados.
Obtén más información sobre cómo 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 mediante 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

Emitir 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?