此页面由 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 池中添加多个从属 CA 有助于您更好地对证书请求进行负载均衡，并提高总有效 QPS。

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

控制台

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

前往 Certificate Authority Service
点击 CA 管理器标签页。
点击创建 CA。

选择 CA 类型

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

配置 CA 主题名称

在组织 (O) 字段中，输入贵公司的名称。
可选：在组织部门 (OU) 字段中，输入公司分支或业务部门。
可选：在国家/地区名称字段中，输入两个字母的国家/地区代码。
可选：在州或省名称字段中，输入您所在的州/省的名称。
可选：在地理位置名称字段中，输入您所在的城市的名称。
在 CA 通用名称 (CN) 字段中，输入 CA 名称。
在 Pool 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 添加标签，请执行以下操作：

点击 Add item（添加内容）。
在密钥 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 pools create。
在创建的 CA 池中创建从属 CA。

注意：您可以通过从“create”命令复制 ID 或利用 gcloud privateca pools list 命令来获取签发者的资源 ID (POOL_ID)。
```
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" {
  // 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

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


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，请执行以下操作：

控制台

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

前往 Certificate Authority Service
点击 CA 管理器标签页。
在证书授权机构下，选择要启用的 CA。
点击 Activate（激活）。
在打开的对话框中，点击 Download CSR（下载 CSR），下载可供签发 CA 签名的 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。

后续步骤

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