Crea una autoridad certificadora subordinada

En esta página, se describe cómo crear autoridades certificadoras (AC) subordinadas en un grupo de AC.

Las AC subordinadas son responsables de emitir certificados directamente a entidades finales, como usuarios, computadoras y dispositivos. Las AC subordinadas están firmadas de forma criptográfica por una AC superior, que suele ser la AC raíz. Como resultado, los sistemas que confían en la AC raíz confían de forma automática en las AC subordinadas y en los certificados de entidad final que emiten las AC subordinadas.

Antes de comenzar

  • Asegúrate de tener el rol de IAM de administrador de operaciones de CA Service (roles/privateca.caManager) o de administrador de CA Service (roles/privateca.admin). Para obtener más información, consulta Configura políticas de IAM.
  • Crea un grupo de AC.
  • Selecciona tu CA raíz.
  • Si el grupo de AC que contiene tu AC raíz emisora tiene configurada una política de emisión de certificados, verifica que sus baselineValues permitan emitir certificados de la AC caOptions.isCa: true, keyUsage.baseKeyUsage.certSign: true y keyUsage.baseKeyUsage.crlSign: true. De lo contrario, la activación de la AC subordinada fallará con el mensaje de error Fields in the CSR were modified or removed in the signed CA certificate.

Crea una AC subordinada

Las AC subordinadas son más fáciles de revocar y rotar que las AC raíz. Si tienes varias situaciones de emisión de certificados, puedes crear una AC subordinada para cada una. Agregar varias AC subordinadas en un grupo de AC te ayuda a lograr un mejor balanceo de cargas de solicitudes de certificado y un QPS efectivo total más alto.

Para crear una AC subordinada, haz lo siguiente:

Console

  1. Ve a la página Certificate Authority Service en la consola deGoogle Cloud .

    Ir a Certificate Authority Service

  2. Haz clic en la pestaña Administrador de CA.

  3. Haz clic en Crear CA.

    Crea una CA con la consola de Cloud.

Selecciona un tipo de CA

  1. Haz clic en AC subordinada.
  2. Haz clic en La AC raíz está en Google Cloud.
  3. En el campo Válido durante, ingresa la duración que deseas que tenga el certificado de la AC.
  4. Opcional: Elige el nivel de la CA. El nivel predeterminado es Enterprise. Para obtener más información, consulta Selecciona los niveles de operación.
  5. Haz clic en Región para seleccionar una ubicación para la AC. Para obtener más información, consulta Ubicaciones.
  6. Opcional: En Estado inicializado, selecciona el estado operativo en el que se creará la AC.
  7. Opcional: En Configura una situación de emisión, haz clic en Perfil de certificado y selecciona el perfil de certificado que mejor se adapte a tus requisitos de la lista. Para obtener más información, consulta Perfiles de certificado.
  8. Haz clic en Siguiente.
Configura un nombre del asunto de CA
  1. Opcional: En el campo Organización (O), ingresa el nombre de tu empresa.
  2. Opcional: En el campo Unidad organizativa (UO), ingresa la subdivisión de la empresa o la unidad de negocios.
  3. Opcional: En el campo Nombre del país (C), ingresa un código de país de dos letras.
  4. Opcional: En el campo Nombre del estado o provincia, ingresa el nombre de tu estado.
  5. Opcional: En el campo Nombre de la localidad, ingresa el nombre de tu ciudad.
  6. En el campo Nombre común de CA (CN), ingresa el nombre de la CA.
  7. Haz clic en Continuar.
Configurar el algoritmo y el tamaño de la clave de CA
  1. Elige el algoritmo de clave que mejor se adapte a tus necesidades. Para obtener más detalles sobre las opciones de claves de firma, consulta Configura claves de firma de AC.
  2. Para usar una clave de firma administrada por el cliente, selecciona Clave administrada por el cliente y proporciona la versión de la clave criptográfica de Cloud Key Management Service.
  3. Haz clic en Continuar.
Configurar artefactos de CA
  1. Elige si quieres usar un bucket de Cloud Storage administrado por Google o por el cliente.
    1. En el caso de un bucket de Cloud Storage administrado por Google, CA Service crea un bucket administrado por Google en la misma ubicación que la CA.
    2. En el caso de un bucket de Cloud Storage administrado por el cliente, haz clic en Explorar y selecciona uno de los buckets de Cloud Storage existentes.
  2. Haz clic en Continuar.
Agrega etiquetas

Los siguientes pasos son opcionales.

Si deseas agregar etiquetas a la CA, haz lo siguiente:

  1. Haz clic en Agregar elemento.
  2. En el campo Clave 1, ingresa la clave de la etiqueta.
  3. En el campo Valor 1, ingresa el valor de la etiqueta.
  4. Si deseas agregar otra etiqueta, haz clic en Agregar elemento. Luego, agrega la clave y el valor de la etiqueta, como se menciona en los pasos 2 y 3.
  5. Haz clic en Continuar.
Revisa la configuración

Revisa con atención todos los parámetros de configuración y, luego, haz clic en Listo para crear la AC.

gcloud

  1. Crea un grupo de AC para la AC subordinada:

    gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
    

    Reemplaza lo siguiente:

    • SUBORDINATE_POOL_ID: Es el nombre del grupo de AC.
    • LOCATION: Es la ubicación en la que deseas crear el grupo de AC. Para obtener la lista completa de ubicaciones, consulta Ubicaciones.

    Para obtener más información sobre cómo crear grupos de AC, consulta Crea un grupo de AC.

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

  2. Crea una AC subordinada en el grupo de AC creado.

    Asegúrate de que --issuer-pool especifique el ID del grupo de AC emisor (no el ID de recurso de la AC raíz). Además, si el grupo de AC emisor tiene configurada una política de emisión, su baselineValues debe permitir certificados de AC:

    baselineValues:
      caOptions:
        isCa: true
      keyUsage:
        baseKeyUsage:
          certSign: true
          crlSign: true
    

    Si el grupo de AC emisora restringe la emisión a certificados de entidad final, la activación de la AC subordinada falla con el mensaje de error Fields in the CSR were modified or removed in the signed CA certificate.

    gcloud privateca subordinates create SUBORDINATE_CA_ID \
        --pool=SUBORDINATE_POOL_ID \
        --location=LOCATION \
        --issuer-pool=ISSUER_POOL_ID \
        --issuer-location=ISSUER_LOCATION \
        --key-algorithm="ec-p256-sha256" \
        --subject="CN=Example Server TLS CA, O=Example LLC"
    

    Reemplaza lo siguiente:

    • SUBORDINATE_CA_ID: Es el identificador único de la AC subordinada.
    • SUBORDINATE_POOL_ID: Es el nombre del grupo de AC.
    • LOCATION: Es la ubicación del grupo de AC.
    • ISSUER_POOL_ID: Es el nombre del grupo de AC que contiene la AC emisora.
    • ISSUER_LOCATION: Es la ubicación del grupo de AC que contiene la AC emisora.

      La marca --key-algorithm especifica el algoritmo criptográfico que deseas usar para crear una clave de Cloud HSM administrada para la CA.

      La marca --subject especifica el nombre X.501 del sujeto del certificado.

    Para crear una AC subordinada con una clave de firma administrada por el cliente, ejecuta el siguiente comando:

    gcloud privateca subordinates create SUBORDINATE_CA_ID \
        --pool=SUBORDINATE_POOL_ID \
        --location=LOCATION \
        --issuer-pool=ISSUER_POOL_ID \
        --issuer-location=ISSUER_LOCATION \
        --kms-key-version=KMS_KEY_VERSION \
        --subject="CN=Example Server TLS CA, O=Example LLC"
    

    Reemplaza lo siguiente:

    • SUBORDINATE_POOL_ID: Es el nombre del grupo de AC.
    • LOCATION: Es la ubicación del grupo de AC.
    • ISSUER_POOL_ID: Es el nombre del grupo de AC que contiene la AC emisora.
    • ISSUER_LOCATION: Es la ubicación del grupo de AC que contiene la AC emisora.
    • KMS_KEY_VERSION: Es el ID de recurso completo de una versión de clave criptográfica de Cloud KMS administrada por el cliente que se usará como clave de firma.

    Para obtener más detalles sobre las opciones de claves de firma y cómo preparar una clave de firma administrada por el cliente, consulta Configura claves de firma de AC.

    Cuando se crea la AC subordinada, se devuelve la siguiente sentencia.

    Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
    

    Para especificar las URLs de acceso personalizadas de acceso a la información de la autoridad (AIA) y del punto de distribución de CRL (CDP), usa las marcas --custom-aia-urls y --custom-cdp-urls. Si se especifican, estas URLs se incluyen en todos los certificados que emite la AC y reemplazan las URLs de acceso predeterminadas al bucket de Cloud Storage.

    Para ver una lista exhaustiva de los parámetros de configuración, ejecuta el siguiente comando de gcloud:

    gcloud privateca subordinates create --help
    

    El comando devuelve ejemplos para crear una AC subordinada cuya entidad emisora se encuentra en CA Service o en otro lugar.

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  // 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-certificate-authority-root"
  location                               = "us-central1"
  deletion_protection                    = false # set to true to prevent destruction of the resource
  ignore_active_certificates_on_deletion = true
  config {
    subject_config {
      subject {
        organization = "ACME"
        common_name  = "my-certificate-authority"
      }
    }
    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 {
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  // valid for 10 years
  lifetime = "${10 * 365 * 24 * 3600}s"
}

resource "google_privateca_certificate_authority" "sub_ca" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-sub-pool"
  certificate_authority_id = "my-certificate-authority-sub"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  subordinate_config {
    certificate_authority = google_privateca_certificate_authority.root_ca.name
  }
  config {
    subject_config {
      subject {
        organization = "ACME"
        common_name  = "my-subordinate-authority"
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs.
        # Use e.g.
        #    max_issuer_path_length = 1
        # if you need to chain more subordinates.
        zero_max_issuer_path_length = true
      }
      key_usage {
        base_key_usage {
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
        }
      }
    }
  }
  // valid for 5 years
  lifetime = "${5 * 365 * 24 * 3600}s"
  key_spec {
    algorithm = "RSA_PKCS1_2048_SHA256"
  }
  type = "SUBORDINATE"
}

Java

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 com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.CertificateAuthority;
import com.google.cloud.security.privateca.v1.CertificateAuthority.KeyVersionSpec;
import com.google.cloud.security.privateca.v1.CertificateAuthority.SignHashAlgorithm;
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.CreateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
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.longrunning.Operation;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateSubordinateCa {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, 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: Set it to the CA Pool under which the CA should be created.
    // subordinateCaName: Unique name for the Subordinate CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";

    createSubordinateCertificateAuthority(project, location, poolId, subordinateCaName);
  }

  public static void createSubordinateCertificateAuthority(
      String project, String location, String poolId, String subordinateCaName)
      throws IOException, ExecutionException, InterruptedException {
    // 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()) {

      String commonName = "commonname";
      String orgName = "csr-org-name";
      String domainName = "dns.example.com";
      int caDuration = 100000; // Validity of this CA in seconds.

      // Set the type of Algorithm.
      KeyVersionSpec keyVersionSpec =
          KeyVersionSpec.newBuilder().setAlgorithm(SignHashAlgorithm.RSA_PKCS1_4096_SHA256).build();

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

      //  Set the key usage options for X.509 fields.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder().setCrlSign(true).setCertSign(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).build())
              .build();

      // Set certificate authority settings.
      CertificateAuthority subCertificateAuthority =
          CertificateAuthority.newBuilder()
              .setType(CertificateAuthority.Type.SUBORDINATE)
              .setKeySpec(keyVersionSpec)
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              // Set the CA validity duration.
              .setLifetime(Duration.newBuilder().setSeconds(caDuration).build())
              .build();

      // Create the CertificateAuthorityRequest.
      CreateCertificateAuthorityRequest subCertificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(subordinateCaName)
              .setCertificateAuthority(subCertificateAuthority)
              .build();

      // Create Subordinate CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(subCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while creating Subordinate CA !" + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority created successfully : " + subordinateCaName);
    }
  }
}

Python

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 google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    common_name: str,
    organization: str,
    domain: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority (CA) which is the subordinate CA 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: set it to the CA Pool under which the CA should be created.
        subordinate_ca_name: unique name for the Subordinate CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        domain: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    # Set the type of Algorithm
    key_version_spec = privateca_v1.CertificateAuthority.KeyVersionSpec(
        algorithm=privateca_v1.CertificateAuthority.SignHashAlgorithm.RSA_PKCS1_4096_SHA256
    )

    # Set CA subject config.
    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(
            common_name=common_name, organization=organization
        ),
        # Set the fully qualified domain name.
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain]),
    )

    # Set the key usage options for X.509 fields.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                crl_sign=True,
                cert_sign=True,
            )
        ),
        ca_options=privateca_v1.X509Parameters.CaOptions(
            is_ca=True,
        ),
    )

    # Set certificate authority settings.
    certificate_authority = privateca_v1.CertificateAuthority(
        type_=privateca_v1.CertificateAuthority.Type.SUBORDINATE,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        # Set the CA validity duration.
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

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

    # Create the CertificateAuthorityRequest.
    request = privateca_v1.CreateCertificateAuthorityRequest(
        parent=ca_pool_path,
        certificate_authority_id=subordinate_ca_name,
        certificate_authority=certificate_authority,
    )

    operation = ca_service_client.create_certificate_authority(request=request)
    result = operation.result()

    print(f"Operation result: {result}")

Habilita una AC subordinada

Para habilitar una AC subordinada, haz lo siguiente:

Console

  1. Ve a la página Certificate Authority Service en la consola deGoogle Cloud .

    Ir a Certificate Authority Service

  2. Haz clic en la pestaña Administrador de CA.

  3. En Autoridades certificadoras, selecciona la AC que deseas habilitar.

  4. Haz clic en play_circleHabilitar.

gcloud

Para habilitar una AC subordinada recién creada, ejecuta el siguiente comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID \
--pool=SUBORDINATE_POOL_ID \
--location=LOCATION

Reemplaza lo siguiente:

  • SUBORDINATE_CA_ID: Es el identificador único de la AC subordinada.
  • SUBORDINATE_POOL_ID: Es el nombre del grupo de AC que contiene la AC subordinada.
  • LOCATION: Es la ubicación del grupo de AC. Para obtener la lista completa de ubicaciones, consulta Ubicaciones.

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

Terraform

Establece el campo desired_state como ENABLED en la AC subordinada y ejecuta terraform apply.

Java

Para activar la AC subordinada con un certificado firmado, llama a la RPC ActivateCertificateAuthority:


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.ActivateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.SubordinateConfig;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class ActivateSubordinateCa {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, 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: Set a unique id for the CA pool.
    // subordinateCaName: The CA to be activated.
    // pemCaCertificate: The signed certificate, obtained by signing the CSR.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";
    String pemCaCertificate =
        "-----BEGIN CERTIFICATE-----\n" + "sample-pem-certificate\n" + "-----END CERTIFICATE-----";

    // certificateAuthorityName: The name of the certificate authority which signed the CSR.
    // If an external CA (CA not present in Google Cloud) was used for signing,
    // then use the CA's issuerCertificateChain.
    String certificateAuthorityName = "certificate-authority-name";

    activateSubordinateCa(
        project, location, poolId, certificateAuthorityName, subordinateCaName, pemCaCertificate);
  }

  // Activate a subordinate CA.
  // *Prerequisite*: Get the CSR of the subordinate CA signed by another CA. Pass in the signed
  // certificate and (issuer CA's name or the issuer CA's Certificate chain).
  // *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
  public static void activateSubordinateCa(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String subordinateCaName,
      String pemCaCertificate)
      throws ExecutionException, InterruptedException, 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()) {
      // Subordinate CA parent.
      String subordinateCaParent =
          CertificateAuthorityName.of(project, location, poolId, subordinateCaName).toString();

      // Construct the "Activate CA Request".
      ActivateCertificateAuthorityRequest activateCertificateAuthorityRequest =
          ActivateCertificateAuthorityRequest.newBuilder()
              .setName(subordinateCaParent)
              // The signed certificate.
              .setPemCaCertificate(pemCaCertificate)
              .setSubordinateConfig(
                  SubordinateConfig.newBuilder()
                      // Follow one of the below methods:

                      // Method 1: If issuer CA is in Google Cloud, set the Certificate Authority
                      // Name.
                      .setCertificateAuthority(
                          CertificateAuthorityName.of(
                                  project, location, poolId, certificateAuthorityName)
                              .toString())

                      // Method 2: If issuer CA is external to Google Cloud, set the issuer's
                      // certificate chain.
                      // The certificate chain of the CA (which signed the CSR) from leaf to root.
                      // .setPemIssuerChain(
                      //     SubordinateConfigChain.newBuilder()
                      //         .addAllPemCertificates(issuerCertificateChain)
                      //         .build())

                      .build())
              .build();

      // Activate the CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .activateCertificateAuthorityCallable()
              .futureCall(activateCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while activating the subordinate CA! " + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority activated successfully ! !" + subordinateCaName);
      TimeUnit.SECONDS.sleep(3);
      // The current state will be STAGED.
      // The Subordinate CA has to be ENABLED before issuing certificates.
      System.out.println(
          "Current State: "
              + certificateAuthorityServiceClient
              .getCertificateAuthority(subordinateCaParent)
              .getState());
    }
  }
}

Para habilitar la AC subordinada de modo que pueda emitir certificados, llama a la RPC EnableCertificateAuthority:


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CertificateAuthority.State;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.EnableCertificateAuthorityRequest;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class EnableCertificateAuthority {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, 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: The id of the CA pool under which the CA is present.
    // certificateAuthorityName: The name of the CA to be enabled.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    enableCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Enable the Certificate Authority present in the given ca pool.
  // CA cannot be enabled if it has been already deleted.
  public static void enableCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws IOException, ExecutionException, InterruptedException {
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {
      // Create the Certificate Authority Name.
      CertificateAuthorityName certificateAuthorityParent =
          CertificateAuthorityName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .setCertificateAuthority(certificateAuthorityName)
              .build();

      // Create the Enable Certificate Authority Request.
      EnableCertificateAuthorityRequest enableCertificateAuthorityRequest =
          EnableCertificateAuthorityRequest.newBuilder()
              .setName(certificateAuthorityParent.toString())
              .build();

      // Enable the Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .enableCertificateAuthorityCallable()
              .futureCall(enableCertificateAuthorityRequest);
      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while enabling Certificate Authority !" + response.getError());
        return;
      }

      // Get the current CA state.
      State caState =
          certificateAuthorityServiceClient
              .getCertificateAuthority(certificateAuthorityParent)
              .getState();

      // Check if the CA is enabled.
      if (caState == State.ENABLED) {
        System.out.println("Enabled Certificate Authority : " + certificateAuthorityName);
      } else {
        System.out.println(
            "Cannot enable the Certificate Authority ! Current CA State: " + caState);
      }
    }
  }
}

Python

Para activar la AC subordinada con un certificado firmado, llama a la RPC ActivateCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def activate_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    pem_ca_certificate: str,
    ca_name: str,
) -> None:
    """
    Activate a subordinate Certificate Authority (CA).
    *Prerequisite*: Get the Certificate Signing Resource (CSR) of the subordinate CA signed by another CA. Pass in the signed
    certificate and (issuer CA's name or the issuer CA's Certificate chain).
    *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
    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 it to the CA Pool under which the CA should be created.
        pem_ca_certificate: the signed certificate, obtained by signing the CSR.
        subordinate_ca_name: the CA to be activated.
        ca_name: The name of the certificate authority which signed the CSR.
            If an external CA (CA not present in Google Cloud) was used for signing,
            then use the CA's issuerCertificateChain.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    subordinate_ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, subordinate_ca_name
    )
    ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Set CA subordinate config.
    subordinate_config = privateca_v1.SubordinateConfig(
        # Follow one of the below methods:
        # Method 1: If issuer CA is in Google Cloud, set the Certificate Authority Name.
        certificate_authority=ca_path,
        # Method 2: If issuer CA is external to Google Cloud, set the issuer's certificate chain.
        # The certificate chain of the CA (which signed the CSR) from leaf to root.
        # pem_issuer_chain=privateca_v1.SubordinateConfig.SubordinateConfigChain(
        #     pem_certificates=issuer_certificate_chain,
        # )
    )

    # Construct the "Activate CA Request".
    request = privateca_v1.ActivateCertificateAuthorityRequest(
        name=subordinate_ca_path,
        # The signed certificate.
        pem_ca_certificate=pem_ca_certificate,
        subordinate_config=subordinate_config,
    )

    # Activate the CA
    operation = ca_service_client.activate_certificate_authority(request=request)
    result = operation.result()

    print("Operation result:", result)

    # The current state will be STAGED.
    # The Subordinate CA has to be ENABLED before issuing certificates.
    print(
        f"Current state: {ca_service_client.get_certificate_authority(name=subordinate_ca_path).state}"
    )

Para habilitar la AC subordinada de modo que pueda emitir certificados, llama a la RPC EnableCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def enable_certificate_authority(
    project_id: str, location: str, ca_pool_name: str, ca_name: str
) -> None:
    """
    Enable the Certificate Authority present in the given ca pool.
    CA cannot be enabled if it has been already deleted.

    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: the name of the CA pool under which the CA is present.
        ca_name: the name of the CA to be enabled.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()
    ca_path = caServiceClient.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Create the Enable Certificate Authority Request.
    request = privateca_v1.EnableCertificateAuthorityRequest(
        name=ca_path,
    )

    # Enable the Certificate Authority.
    operation = caServiceClient.enable_certificate_authority(request=request)
    operation.result()

    # Get the current CA state.
    ca_state = caServiceClient.get_certificate_authority(name=ca_path).state

    # Check if the CA is enabled.
    if ca_state == privateca_v1.CertificateAuthority.State.ENABLED:
        print("Enabled Certificate Authority:", ca_name)
    else:
        print("Cannot enable the Certificate Authority ! Current CA State:", ca_state)

¿Qué sigue?