Cómo solicitar un certificado y ver los certificados emitidos

En este tema, se describe cómo puedes solicitar un certificado de Certificate Authority Service y ver los certificados emitidos.

Antes de comenzar

Asegúrate de tener la función de IAM de Administrador de certificados del servicio de CA (roles/privateca.certificateManager) o de solicitante de certificados del servicio de CA (roles/privateca.certificateRequester). Si deseas obtener más información sobre las funciones predefinidas de IAM para el servicio de CA, consulta Control de acceso con IAM.

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

Descripción general

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).
Haz que CA Service cree una clave privada o pública por ti.
Usar una clave de Cloud Key Management Service (Cloud KMS) existente

Solicita un certificado mediante una CSR

Antes de continuar, debes generar una CSR. Después de generar una CSR, haz lo siguiente:

Console

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

Ir a Certificate Authority Service
Haz clic en la pestaña Administrador de CA.
Haz clic en el nombre de la AC desde la que deseas emitir.
En la parte inferior de la página de detalles de la AC, haz clic en Solicitar un certificado.
Opcional: Si deseas usar una plantilla de certificado, haz clic en , selecciona una plantilla de la lista y haz clic en Guardar.
Haz clic en Provide CSR.
Opcional: Para reemplazar el nombre del certificado generado automáticamente, ingresa el nombre personalizado en el campo 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 Certificado de CSR. Para subir la CSR, haz clic en Explorar.
Haz clic en Siguiente.

Descargar el certificado firmado

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.
Haz clic en Listo.

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 crea certificados de gcloud privateca.

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 preferido, como openssl.

A continuación, se muestra una CSR de muestra codificada para JSON.

Solicita un certificado.

HTTP method and 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: 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:
```
$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 Cómo crear AC.

Cómo solicitar un certificado con una clave generada automáticamente

Console

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

En la consola de Google Cloud, ve a la página Certificate Authority Service.

Ir a Certificate Authority Service
Haz clic en la pestaña Administrador de CA.
Haz clic en el nombre de la AC desde la que deseas emitir.
En la parte inferior de la página de detalles de la autoridad certificadora, haz clic en Solicitar un certificado.
Opcional: Si deseas usar una plantilla de certificado, haz clic en , selecciona una plantilla de la lista y haz clic en Guardar.
Haz clic en Ingresar detalles.
Opcional: Reemplaza el 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

En Uso extendido de la clave, selecciona una de las siguientes opciones según tu caso de uso (opcional):
- TLS del servidor: Estos certificados te permiten autenticar la identidad de un servidor.
- TLS de cliente: estos certificados te permiten autenticar la identidad de un solicitante.
Haz clic en Siguiente.

Configura el tamaño de la clave y el algoritmo

Opcional: En Configura el tamaño y el algoritmo de la clave de firma, selecciona el tamaño y el algoritmo de la clave de firma de la lista. Si omites este paso, se usa la clave RSA de 2048 bits con un resumen SHA 256. Para obtener información sobre cómo seleccionar una clave de firma y un algoritmo, consulta Cómo elegir un algoritmo de clave.
Haz clic en Continuar.

Descargar el certificado firmado

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 abandonar esta página. Esta clave es sensible. Te recomendamos que protejas la clave en una ubicación segura.
Haz clic en Listo.

Importante: Si usas un grupo de AC de DevOps, esta es la única vez que podrás 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 la autoridad criptográfica de Python (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 que se genera.
CERT_FILENAME: La ruta de acceso en la que se debe escribir el archivo de cadena de certificados con codificación PEM. La cadena de certificados se ordena desde la entidad final hasta la raíz.
DNS_NAME: Uno o más nombres alternativos de asunto de DNS (SAN) separados por comas
CERTIFICATE_PROFILE: Es el identificador único del perfil de certificado. Por ejemplo, usa leaf_server_tls para la TLS del servidor de entidad final.

El comando gcloud menciona las siguientes marcas:

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

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 crea certificados de gcloud privateca.

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

Si quieres usar una clave de Cloud KMS para crear un certificado TLS del 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 se ordena de la entidad final a la raíz.
DNS_NAME: SAN de DNS separados por comas.

Realiza operaciones comunes con certificados

En esta sección, se describe cómo puedes realizar ciertas operaciones comunes con certificados.

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

gcloud

Si quieres orientarte a una AC específica del 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"

Console

La consola de Google Cloud solo admite la emisión de certificados de una AC en particular. Sigue las instrucciones en la sección Solicita un certificado mediante una clave generada de forma automática o la sección Solicita un certificado mediante una CSR para elegir la AC que debe emitir el certificado.

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
}

Ver los certificados emitidos

Console

En la consola de Google Cloud, ve a la página Certificate Authority Service.

Ir a Certificate Authority Service
Haz clic en la pestaña Administrador de CA.
En la página Autoridades de certificación, haz clic en el nombre de la AC.
En la parte inferior de la página de detalles de la autoridad certificadora, haz clic en Ver certificados emitidos para ver la lista de certificados emitidos por la AC.

Puedes ver los certificados en la página Todos los certificados. Los detalles incluyen el estado del certificado, la AC emisora, el grupo de AC que contiene la AC, la fecha de vencimiento del certificado y mucho más.

gcloud

Para enumerar todos los certificados emitidos por una AC específica en un grupo de AC, usa el siguiente comando gcloud:

gcloud privateca certificates list --issuer-pool ISSUER_POOL --ca CA_NAME

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

Para enumerar todos los certificados de todas las AC en una ubicación determinada, usa el siguiente comando gcloud:

gcloud privateca certificates list --location LOCATION

Go

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/api/iterator"
)

// List Certificates present in the given CA pool.
func listCertificates(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string) 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 exists.

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

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

	// Create the ListCertificatesRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#ListCertificatesRequest.
	req := &privatecapb.ListCertificatesRequest{Parent: fullCaName}

	it := caClient.ListCertificates(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to get the list of cerficates: %w", err)
		}

		fmt.Fprintf(w, " - %s (common name: %s)", resp.Name,
			resp.CertificateDescription.SubjectDescription.Subject.CommonName)
	}

	return nil
}

Java


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 java.io.IOException;

public class ListCertificates {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Id of the CA pool which contains the certificates to be listed.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    listCertificates(project, location, poolId);
  }

  // List Certificates present in the given CA pool.
  public static void listCertificates(String project, String location, String poolId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      CaPoolName caPool =
          CaPoolName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .build();

      // Retrieve and print the certificate names.
      System.out.println("Available certificates: ");
      for (Certificate certificate :
          certificateAuthorityServiceClient.listCertificates(caPool).iterateAll()) {
        System.out.println(certificate.getName());
      }
    }
  }
}

Python


import google.cloud.security.privateca_v1 as privateca_v1

def list_certificates(
    project_id: str,
    location: str,
    ca_pool_name: str,
) -> None:
    """
    List Certificates present in the given CA pool.

    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: name of the CA pool which contains the certificates to be listed.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    ca_pool_path = caServiceClient.ca_pool_path(project_id, location, ca_pool_name)

    # Retrieve and print the certificate names.
    print(f"Available certificates in CA pool {ca_pool_name}:")
    for certificate in caServiceClient.list_certificates(parent=ca_pool_path):
        print(certificate.name)

Ver detalles de un solo certificado

Console

En la consola de Google Cloud, ve a la página Certificate Authority Service.

Ir a Certificate Authority Service
Elige tu AC objetivo en la pestaña Administrador de AC.
Haz clic en el nombre de la AC.
En la parte inferior de la página de detalles de la autoridad certificadora, haz clic en Ver los certificados emitidos para ver la lista de estos.
Haz clic en en la columna Acciones del certificado que deseas descargar.
En Descargar, haz clic en Certificado. Haz clic en Cadena de certificados para descargar la cadena de certificados.

gcloud

Para ver la descripción completa de un certificado, ejecuta el siguiente comando:

gcloud privateca certificates describe CERT_NAME \
    --issuer-pool POOL_ID

Para obtener más información sobre el comando gcloud privateca certificates describe, consulta cómo describir certificados de gcloud privateca.

Para exportar la cadena de certificados X.509 con codificación PEM a un archivo, ejecuta el siguiente comando:

gcloud privateca certificates export CERT_NAME \
    --issuer-pool POOL_ID \
    --include-chain \
    --output-file certificate-file

Para obtener más información sobre el comando gcloud privateca certificates export, consulta cómo exportar certificados de gcloud privateca.

Comprobantes de posesión de certificados

La prueba de posesión de la clave privada garantiza que el solicitante de un certificado tenga la clave privada para ese certificado. El Servicio de CA verifica la prueba de posesión solo si el solicitante proporciona una CSR de PKCS #10 según RFC 2986. No se aplica la prueba de posesión de otras formas de solicitudes de certificados, como las solicitudes de CertificateConfig.

Es responsabilidad de las aplicaciones cliente que aceptan certificados validar si el titular del certificado posee la clave privada de ese certificado. Realizar verificaciones de prueba de posesión durante la emisión del certificado es una forma de defensa en profundidad para proteger a los clientes que no se comportan mal. La existencia de dichos clientes, independientemente de si la AC verifica las pruebas de posesión, podría constituir una vulnerabilidad de seguridad.

¿Qué sigue?

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

Cómo solicitar un certificado y ver los certificados emitidos

Antes de comenzar

Descripción general

Solicita un certificado mediante una CSR

Console

gcloud

Terraform

API de REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Cómo solicitar un certificado con una clave generada automáticamente

Console

gcloud

Go

Java

Python

Solicita un certificado con una clave de Cloud KMS existente

Realiza operaciones comunes con certificados

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

gcloud

Console

Terraform

Ver los certificados emitidos

Console

gcloud

Go

Java

Python

Ver detalles de un solo certificado

Console

gcloud

Comprobantes de posesión de certificados

¿Qué sigue?