此页面由 Cloud Translation API 翻译。

创建从属证书授权机构

本页面介绍了如何在 CA 池中创建从属证书授权机构 (CA)。

从属 CA 负责直接向最终用户、计算机和设备等最终实体。从属 CA 以加密形式由父 CA（通常是根 CA）签名。因此，信任根 CA 的系统会自动信任从属 CA 以及从属 CA 颁发的最终实体证书。

准备工作

确保您拥有 CA Service Operation Manager (roles/privateca.caManager) 或 CA Service Admin (roles/privateca.admin) IAM 角色。有关详情，请参阅配置 IAM 政策。
创建 CA 池。
选择您的根 CA。

创建从属 CA

从属 CA 比根 CA 更容易撤消和轮替。如果您有多个证书颁发场景，您可以为每种场景下在 CA 池中添加多个从属 CA 有助于您可以更好地对证书请求进行负载均衡总有效 QPS。

如需创建从属 CA，请执行以下操作：

控制台

前往 Google Cloud 控制台中的 Certificate Authority Service 页面。

转到 Certificate Authority Service
点击 CA 管理员标签页。
点击创建 CA。

选择 CA 类型

点击从属 CA。
点击根 CA 位于 Google Cloud 中。
在有效期字段中，输入所需的时长 CA 证书才有效
可选：为 CA 选择层级。默认层级为企业。如需了解详情，请参阅选择操作层级。
点击区域，为 CA 选择一个位置。有关相关信息，请参阅位置。
可选：在初始化状态下，选择 CA 必须的州所有角色
可选：在设置发证场景下，点击证书配置文件，然后从列表中选择最符合您要求的证书配置文件。如需了解详情，请参阅证书配置文件。
点击下一步。

配置 CA 正文名称

在组织 (O) 字段中，输入贵公司的名称。
可选：在组织部门 (OU) 字段中，输入公司下属行政单位或业务部门。
可选：在国家/地区名称字段中，输入两个字母的国家/地区代码。
可选：在州或省名称字段中，输入您所在的州/省的名称。
可选：在地理位置名称字段中，输入您所在的城市的名称。
在 CA 通用名称 (CN) 字段中，输入 CA 名称。
在池 ID 字段中，输入 CA 池名称。您无法更改在创建 CA 后创建的 CA 池。
点击下一步。

配置 CA 密钥大小和算法

选择最符合您需求的密钥算法。相关信息如何确定合适的密钥算法，请参阅选择密钥算法。
点击下一步。

配置 CA 工件

以下步骤是可选的。如果您跳过这些步骤，系统会应用默认设置。

选择要使用 Google 管理的 Cloud Storage 存储桶还是自行管理的 Cloud Storage 存储桶。

如果您未选择自有 Cloud Storage 存储桶，CA Service 会在与 CA 相同的位置创建一个 Google 管理的存储桶。

选择是否要禁止发布证书吊销列表 (CRL) 和 CA 证书传送到 Cloud Storage 存储桶。

默认情况下，系统会启用在 Cloud Storage 存储桶中发布 CRL 和 CA 证书的功能。要停用这些设置，请点击切换开关。

点击下一步。

添加标签

以下步骤是可选的。

如果要向 CA 添加标签，请执行以下操作：

点击 添加一项。
在密钥 1 字段中，输入标签键。
在值 1 字段中，输入标签值。
如果您想添加其他标签，请点击 Add item（添加项）。然后，添加标签键和值（如第 2 步和第 3 步所述）。
点击下一步。

查看设置

仔细检查所有设置，然后点击创建以创建 CA。

gcloud

为从属 CA 创建 CA 池：
```
gcloud privateca pools create SUBORDINATE_POOL_ID
```
将 SUBORDINATE_POOL_ID 替换为 CA 池的名称。

如需详细了解如何创建 CA 池，请参阅创建 CA 池。

如需详细了解 gcloud privateca pools create 命令，请参阅 gcloud privateca buckets create。
在创建的 CA 池中创建从属 CA。

注意：您可以获取发卡机构的资源 ID (POOL_ID) 方法是复制 create 命令中的 ID，或利用 gcloud privateca pools list 命令。
```
gcloud privateca subordinates create SUBORDINATE_CA_ID \
  --pool=SUBORDINATE_POOL_ID \
  --issuer-pool=POOL_ID \
  --key-algorithm="ec-p256-sha256" \
  --subject="CN=Example Server TLS CA, O=Example LLC"
```
创建从属 CA 时，系统会返回以下语句。
```
Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
```
如需查看完整的设置列表，请运行以下 gcloud 命令：
```
gcloud privateca subordinates create --help
```
该命令会返回一些示例，用于创建其颁发者位于 CA 服务上或位于其他位置的从属 CA。

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  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 = "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_authority" "default" {
  // 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-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 = "HashiCorp"
        common_name  = "my-subordinate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs
        max_issuer_path_length = 0
      }
      key_usage {
        base_key_usage {
          digital_signature  = true
          content_commitment = true
          key_encipherment   = false
          data_encipherment  = true
          key_agreement      = true
          cert_sign          = true
          crl_sign           = true
          decipher_only      = true
        }
        extended_key_usage {
          server_auth      = true
          client_auth      = false
          email_protection = true
          code_signing     = true
          time_stamping    = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  type = "SUBORDINATE"
}

Java

如需向 CA 服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。


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

如需向 CA Service 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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

启用从属 CA

如需启用子 CA，请执行以下操作：

控制台

转到 Certificate Authority Service 页面： Google Cloud 控制台

转到 Certificate Authority Service
点击 CA 管理员标签页。
在证书授权机构下，选择要启用的 CA。
点击 Activate（启用）。
在打开的对话框中，点击下载 CSR 以下载 PEM 编码的 CSR 文件，证书颁发机构可以签署该文件。
点击下一步。
在上传证书链字段中，点击浏览。
上传扩展名为 .crt 的已签名证书文件。
点击激活。

gcloud

如需启用新创建的子 CA，请运行以下命令：

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

替换以下内容：

SUBORDINATE_CA_ID：从属 CA 的唯一标识符。
SUBORDINATE_POOL_ID：包含从属 CA 的 CA 池的名称。

如需详细了解 gcloud privateca subordinates enable 命令，请参阅 gcloud privateca subordinates enable。

Terraform

将从属 CA 上的 desired_state 字段设置为 ENABLED，然后运行 terraform apply。

后续步骤

了解如何请求证书。
了解模板和签发政策。