Esta página se ha traducido con Cloud Translation API.

Crear una autoridad de certificación subordinada

En esta página se describe cómo crear autoridades de certificación (CAs) subordinadas en un grupo de CAs.

Las CAs subordinadas son responsables de emitir certificados directamente a entidades finales, como usuarios, ordenadores y dispositivos. Las CAs subordinadas están firmadas criptográficamente por una CA principal, que suele ser la CA raíz. Por lo tanto, los sistemas que confían en la CA raíz confían automáticamente en las CAs subordinadas y en los certificados de entidad final que emiten las CAs subordinadas.

Antes de empezar

Asegúrate de tener el rol de gestión operativa del servicio de AC (roles/privateca.caManager) o el rol de administrador del servicio de AC (roles/privateca.admin) de IAM. Para obtener información, consulta Configurar políticas de gestión de identidades y accesos.
Crea un grupo de autoridades de certificación.
Selecciona tu CA raíz.

Crear una AC subordinada

Las ACs subordinadas son más fáciles de revocar y rotar que las ACs raíz. Si tienes varios casos de emisión de certificados, puedes crear una AC subordinada para cada uno de ellos. Si añades varias ACs subordinadas a un grupo de ACs, podrás conseguir un mejor balanceo de carga de las solicitudes de certificados y un mayor número total de consultas por segundo efectivas.

Para crear una CA subordinada, sigue estos pasos:

Consola

Ve a la página Servicio de autoridad de certificación en la consola deGoogle Cloud .

Ir al Servicio de Autoridades de Certificación
Haga clic en la pestaña Administrador de autoridades de certificación.
Haz clic en Crear CA.

Seleccionar el tipo de autoridad de certificación

Haz clic en Autoridad de certificación subordinada.
Haga clic en La AC raíz está en Google Cloud.
En el campo Válido durante, introduce la duración durante la que quieres que sea válido el certificado de CA.
Opcional: Elige el nivel de la AC. El nivel predeterminado es Enterprise. Para obtener más información, consulta Seleccionar los niveles de operación.
Haz clic en Región para seleccionar una ubicación para la CA. Para obtener más información, consulta Ubicaciones.
Opcional: En Estado inicializado, selecciona el estado en el que debe estar la AC al crearla.
Opcional: En Configurar un escenario de emisión, haga clic en Perfil de certificado y seleccione de la lista el perfil de certificado que mejor se adapte a sus necesidades. Para obtener más información, consulta Perfiles de certificado.
Haz clic en Siguiente.

Configurar el nombre de sujeto de la autoridad de certificación

En el campo Organización (O), introduce el nombre de tu empresa.
Opcional: En el campo Unidad organizativa (UO), introduce el departamento empresarial o la unidad de negocio.
Opcional: En el campo Nombre del país (C), introduce el código de dos letras del país.
Opcional: En el campo Nombre del estado o de la provincia, introduce el nombre de tu estado.
Opcional: En el campo Nombre de la localidad, introduce el nombre de tu ciudad.
En el campo Nombre común de la autoridad de certificación (NC), introduce el nombre de la autoridad de certificación.
Haz clic en Continuar.

Configurar el tamaño de clave y el algoritmo de la autoridad de certificación

Elige el algoritmo de claves que mejor se adapte a tus necesidades. Para obtener información sobre cómo elegir el algoritmo de claves adecuado, consulta Elegir un algoritmo de claves.
Haz clic en Continuar.

Configurar artefactos de la AC

Elige si quieres usar un segmento de Cloud Storage gestionado por Google o por el cliente.

En el caso de un segmento de Cloud Storage gestionado por Google, CA Service crea un segmento gestionado por Google en la misma ubicación que la CA.
En el caso de un segmento de Cloud Storage gestionado por el cliente, haga clic en Examinar y seleccione uno de los segmentos de Cloud Storage.

Haz clic en Continuar.

Añadir etiquetas

Los siguientes pasos son opcionales.

Si quieres añadir etiquetas a la AC, haz lo siguiente:

Haz clic en Añadir elemento.
En el campo Clave 1, introduce la clave de la etiqueta.
En el campo Valor 1, introduce el valor de la etiqueta.
Si quiere añadir otra etiqueta, haga clic en Añadir elemento. A continuación, añade la clave y el valor de la etiqueta, tal como se indica en los pasos 2 y 3.
Haz clic en Continuar.

Revisa los ajustes

Revisa detenidamente todos los ajustes y haz clic en Hecho para crear la AC.

gcloud

Crea un grupo de autoridades de certificación para la autoridad subordinada:
```
gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
```
Haz los cambios siguientes:
- SUBORDINATE_POOL_ID: el nombre del grupo de autoridades de certificación.
- LOCATION: la ubicación en la que quieres crear el grupo de ACs. Para ver la lista completa de ubicaciones, consulta Ubicaciones.
Para obtener más información sobre cómo crear grupos de CAs, consulta Crear un grupo de CAs.

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

Crea una AC subordinada en el grupo de ACs creado.

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

Se devuelve la siguiente instrucción cuando se crea la AC subordinada.

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

Para ver una lista exhaustiva de los ajustes, ejecuta el siguiente comando gcloud:

gcloud privateca subordinates create --help

El comando devuelve ejemplos para crear una AC subordinada cuyo emisor se encuentre en el servicio de AC 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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

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}")

Habilitar una AC subordinada

Para habilitar una AC subordinada, haz lo siguiente:

Consola

Ve a la página Servicio de autoridad de certificación en la consola deGoogle Cloud .

Ir al Servicio de Autoridades de Certificación
Haga clic en la pestaña Administrador de autoridades de certificación.
En Autoridades de certificación, selecciona la AC que quieras activar.
Haz clic en Activar.
En el cuadro de diálogo que se abre, haga clic en Descargar CSR para descargar el archivo CSR codificado en PEM que puede firmar la AC emisora.
Haz clic en Siguiente.
En el campo Subir cadena de certificados, haz clic en Buscar.
Sube el archivo de certificado firmado con la extensión .crt.
Haz clic en Activate (Activar).

gcloud

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

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

Haz los cambios siguientes:

SUBORDINATE_CA_ID: identificador único de la AC subordinada.
SUBORDINATE_POOL_ID: el nombre del grupo de autoridades de certificación que contiene la autoridad de certificación subordinada.
LOCATION: la ubicación del grupo de autoridades de certificación. Para ver 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

Asigna el valor ENABLED al campo desired_state de la AC subordinada y ejecuta terraform apply.

Siguientes pasos

Consulta cómo solicitar certificados.
Consulta información sobre las plantillas y las políticas de emisión.