此页面由 Cloud Translation API 翻译。

请求证书

本页介绍了如何在 Certificate Authority Service 中创建证书请求。

您可以使用以下方法申请证书：

生成您自己的私钥或公钥，并提交证书签名请求 (CSR)。
使用 CA 服务自动生成的私钥或公钥。
使用现有的 Cloud Key Management Service (Cloud KMS) 密钥。

准备工作

为 CA 服务准备好环境。
如需获得颁发证书所需的权限，请让您的管理员为您授予 CA Service Certificate Requester (roles/privateca.certificateRequester) 或 CA Service Certificate Manager (roles/privateca.certificateManager) IAM 角色。

如需详细了解 CA 服务的预定义 IAM 角色，请参阅使用 IAM 进行访问权限控制。

如需了解如何向正文授予 IAM 角色，请参阅授予单个角色。

使用 CSR 请求证书

如需获取证书，您需要生成 CSR，然后使用 CSR 请求证书。

生成 CSR

如需详细了解如何使用 OpenSSL 生成 CSR，请参阅如何使用 OpenSSL 生成 CSR。您还可以在生成 CSR 时使用以下示例配置文件作为参考。

如需使用示例配置文件，请按以下步骤操作：

使用以下配置创建名为 csr.cnf 的配置文件。
```
cat << EOF > csr.cnf
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
prompt = no

[req_distinguished_name]
CN = example.com

[v3_req]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com
DNS.2 = www.example.com
EOF
```
此示例会生成一个 2048 位 RSA 密钥（已通过口令加密）和一个包含以下内容的相应 CSR：
- 主题 DN 中的 commonName 属性
- subjectAlternativeName 扩展程序
- keyUsage 扩展程序（已标记为严重）
- extendedKeyUsage 扩展程序
根据需要修改参数。如需使用 x509v3_config 配置文件格式为 X.509 证书和 CSR 定义扩展程序，请参阅 OpenSSL 文档。
运行以下 openssl 命令以生成 CSR 和相应的私钥：
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
此命令会生成以下文件：
- csr.pem：您的 CSR，已准备好提交给 CA
- key.pem：您的私钥，请妥善保管
在证书请求中使用 csr.pem 文件。

使用 CSR 提交证书请求

如需使用 CSR 请求证书，请按以下步骤操作：

控制台

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

前往 Certificate Authority Service
点击申请证书。
选择区域。区域必须与您打算使用的 CA 池的区域相同。
选择 CA 池。
可选：从 CA 池中选择特定 CA。请注意，如果您选择特定 CA 来颁发证书，则会对该 CA 产生依赖，这会使 CA 轮替变得更加困难。
可选：选择证书模板。如果您使用证书模板，请确保证书模板的政策不会与所选 CA 池的政策冲突。
点击提供证书签名请求 (CSR)，然后点击下一步。系统会显示证书详细信息。
可选：如需覆盖自动生成的证书名称，请在证书名称字段中输入自定义名称。证书一经创建，您便无法删除或重复使用证书名称。
可选：如需为证书选择自定义有效期，请在有效期字段中输入相应值。
将 CSR 复制并粘贴到 Certificate CSR 框中。如果您要上传包含 CSR 的文件，请点击浏览，然后选择您的文件。
点击生成证书。

下载已签名的证书

如需查看生成的证书，请点击查看证书，然后点击查看。
如需复制证书，请点击。如需以 .crt 文件的形式下载证书，请点击 下载证书。
可选：如需下载证书链，请点击 下载证书链。

gcloud

gcloud privateca certificates create CERT_ID \
     --issuer-pool POOL_ID \
     --csr CSR_FILENAME \
     --cert-output-file CERT_FILENAME \
     --validity "P30D"

替换以下内容：

CERT_ID：证书的唯一标识符。
POOL_ID：CA 池的名称。
CSR_FILENAME：用于存储 PEM 编码的 CSR 的文件。

--validity 标志定义了证书的有效期。这是一个可选标志，默认值为 30 天。

如需详细了解 gcloud privateca certificates create 命令，请参阅 gcloud privateca certificates create。

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

REST API

使用您的首选方法（例如 openssl）生成证书签名请求 (CSR)。

以下是经过 JSON 编码的 CSR 示例。

请求证书。

HTTP 方法和网址：

POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID

请求 JSON 正文：

{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$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

您应该收到类似以下内容的 JSON 响应：

{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}

使用自动生成的密钥请求证书

控制台

您可以使用 Google Cloud 控制台生成客户端或服务器 TLS 证书。

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

前往 Certificate Authority Service
点击申请证书。
选择区域。区域必须与您打算使用的 CA 池的区域相同。
选择 CA 池。
点击手动输入详细信息。系统会显示证书详细信息。
可选：将自动生成的证书名称替换为唯一的自定义名称。
可选：如需为证书选择自定义有效期，请在有效期字段中输入相应值。

添加域名

在添加域名下，在域名 1 字段中输入域名。
可选：如果您想添加多个网域名称，请点击添加项，然后在网域名称 2 字段中输入其他网域名称。

扩展的密钥用途

可选：在扩展的密钥用途下，根据您的用例选择以下选项之一：
- 客户端 TLS：借助这些证书，您可以对请求者的身份进行身份验证。
- 服务器 TLS：您可以使用这些证书对服务器的身份进行身份验证。
点击下一步。

配置密钥大小和算法

可选：在配置密钥大小和算法下，从列表中选择签名密钥大小和算法。如果您跳过此步骤，系统将使用具有 SHA 256 摘要的 RSASSA-PSS 2048 位密钥。如需了解如何选择签名密钥和算法，请参阅选择密钥算法。
点击生成证书。

下载已签名的证书

如需查看生成的证书，请点击查看证书，然后点击查看。
可选：如需下载 PEM 编码的证书链，请点击下载证书链。
可选：如需下载关联的 PEM 编码私钥，请点击下载私钥。

重要提示：离开此页面后，您将无法检索此密钥。此密钥是敏感信息。我们建议您将密钥保存在安全的位置。
重要提示：如果您使用的是 DevOps CA 池，则只能在此时下载所创建的证书。CA Service 不会存储此界面之后的证书内容。

gcloud

如需使用自动生成密钥功能，您需要安装 Python 加密权威 (PyCA) 库。如需了解如何安装 Pyca 加密库，请参阅添加 Pyca 加密库。

如需创建证书，请使用以下 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"

替换以下内容：

POOL_ID：CA 池的名称。
KEY_FILENAME：必须将生成的私钥文件写入的路径。
CERT_FILENAME：必须将 PEM 编码的证书链文件写入的路径。证书链的顺序为从最终实体到根。
DNS_NAME：一个或多个以英文逗号分隔的 DNS 主题备用名称 (SAN)。
CERTIFICATE_PROFILE：证书配置文件的唯一标识符。例如，针对端实体服务器 TLS 使用 leaf_server_tls。

gcloud 命令提及了以下标志：

--generate-key：在您的机器上生成新的 RSA-2048 私钥。

您还可以使用以下标志的任意组合：

--dns-san：可让您传递一个或多个以英文逗号分隔的 DNS SAN。
--ip-san：可让您传递一个或多个以英文逗号分隔的 IP SAN。
--uri-san：可让您传递一个或多个以英文逗号分隔的 URI SAN。
--subject：可让您传递证书主题的 X.501 名称。

如需详细了解 gcloud privateca certificates create 命令，请参阅 gcloud privateca certificates create。

Go

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

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

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


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

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

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)

使用现有 Cloud KMS 密钥请求证书

您只能使用 Google Cloud CLI 使用 Cloud KMS 密钥请求证书。

gcloud

如需使用 Cloud KMS 密钥创建端点服务器 TLS 证书，请运行以下命令：

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"

替换以下内容：

POOL_ID：CA 池的名称。
PROJECT_ID：项目 ID。
LOCATION_ID：密钥环的位置。
KEY_RING：密钥所在的密钥环的名称。
KEY：密钥的名称。
KEY_VERSION：密钥的版本。
CERT_FILENAME：PEM 编码的证书链文件的路径。证书链文件的顺序为从最终实体到根。
DNS_NAME：以英文逗号分隔的 DNS SAN。

从 CA 池中的特定 CA 颁发证书

本部分介绍了如何从 CA 池中的特定 CA 颁发证书。

控制台

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

前往 Certificate Authority Service
点击申请证书。
选择区域。区域必须与您打算使用的 CA 池的区域相同。
选择 CA 池。
如需选择 CA，请点击使用此 CA 池中的特定 CA，然后从列表中选择 CA。
选择其他参数，方法与在使用自动生成的密钥请求证书部分或使用 CSR 请求证书部分中所述的相同。

gcloud

如需在 CA 池中定位到特定 CA 以颁发证书，请添加 --ca 标志，并附上必须颁发证书的 CA 的 CA_ID。

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"

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
}

在验证模式下请求证书

在验证模式下请求证书会创建未签名的测试证书。此测试证书未采用 PEM 编码，且无需付费。虽然您无法下载证书，但通过假想的证书说明，您可以确认自己可以使用所选参数成功颁发已签名证书。

如需在验证模式下请求证书，请按以下步骤操作：

控制台

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

前往 Certificate Authority Service
点击申请证书。
选择使用验证模式来查看假设的证书说明，而不是使用签名证书。
请按照申请签名证书的步骤操作。

请求证书

准备工作

使用 CSR 请求证书

生成 CSR

使用 CSR 提交证书请求

控制台

gcloud

Terraform

REST API

curl（Linux、macOS 或 Cloud Shell）

PowerShell (Windows)

使用自动生成的密钥请求证书

控制台

gcloud

Go

Java

Python

使用现有 Cloud KMS 密钥请求证书

gcloud

从 CA 池中的特定 CA 颁发证书

控制台

gcloud

Terraform

在验证模式下请求证书

控制台

后续步骤