このページは Cloud Translation API によって翻訳されました。

証明書をリクエスト

このページでは、Certificate Authority Service で証明書リクエストを作成する方法について説明します。

証明書は、次の方法でリクエストできます。

独自の秘密鍵または公開鍵を生成し、証明書署名リクエスト（CSR）を送信します。
CA Service によって自動生成された秘密鍵または公開鍵を使用します。
既存の Cloud Key Management Service（Cloud KMS）鍵を使用します。

始める前に

CA Service 用に環境を準備します。
証明書を発行するために必要な権限を取得するには、CA Service 証明書リクエスト元（roles/privateca.certificateRequester）または CA Service 証明書マネージャー（roles/privateca.certificateManager）の IAM ロールの付与を管理者に依頼してください。

CA Service の事前定義された 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
```
このサンプルでは、2,048 ビットの RSA 鍵（パスフレーズで暗号化）と、次を含む対応する CSR を生成します。
- 主体者識別名の 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: CA に送信する準備が整った CSR
- key.pem: 秘密鍵。安全な場所に保管する必要があります
証明書リクエストで csr.pem ファイルを使用します。

CSR を使用して証明書リクエストを送信する

CSR を使用して証明書をリクエストする手順は次のとおりです。

Console

Google Cloud コンソールの [Certificate Authority Service] ページに移動します。

Certificate Authority Service に移動
[証明書をリクエスト] をクリックします。
リージョンを選択します。リージョンは、使用する CA プールのリージョンと同じである必要があります。
CA プールを選択します。
省略可: CA プールから特定の CA を選択します。証明書の発行に特定の CA を選択すると、その CA への依存関係が作成され、CA のローテーションが難しくなります。
省略可: 証明書テンプレートを選択します。証明書テンプレートを使用する場合は、証明書テンプレートのポリシーが選択した CA プールのポリシーと競合していないことを確認します。
[証明書署名リクエスト（CSR）を提出する]、[次へ] の順にクリックします。証明書の詳細が表示されます。
省略可: 自動生成された証明書名を上書きするには、[証明書名] フィールドにカスタム名を入力します。証明書の作成後は、証明書名の削除や再利用はできません。
省略可: 証明書のカスタム有効期間を選択するには、[有効期間] フィールドに値を入力します。
CSR をコピーして [証明書 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）を生成します。

次の CSR は JSON 用にエンコードされています。

証明書をリクエストする

HTTP メソッドと URL:
```
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": {...}
}
```
注意: ルート CA からエンドユーザーの証明書を発行しないことをおすすめします。下位 CA の作成については、CA の作成をご覧ください。

自動生成された鍵を使用して証明書をリクエストする

Console

Google Cloud コンソールを使用して、クライアントまたはサーバー TLS 証明書を生成できます。

Google Cloud コンソールの [Certificate Authority Service] ページに移動します。

Certificate Authority Service に移動
[証明書をリクエスト] をクリックします。
リージョンを選択します。リージョンは、使用する CA プールのリージョンと同じである必要があります。
CA プールを選択します。
[詳細を手動で入力する] をクリックします。証明書の詳細が表示されます。
省略可: 自動生成された証明書名を一意のカスタム名に置き換えます。
省略可: 証明書のカスタム有効期間を選択するには、[有効期間] フィールドに値を入力します。

ドメイン名の追加

[ドメイン名を追加] で、[ドメイン名 1] フィールドにドメイン名を入力します。
省略可: 複数のドメイン名を追加する場合は、[アイテムを追加] をクリックし、[ドメイン名 2] フィールドに別のドメイン名を入力します。

鍵の拡張的用途

省略可: [鍵の拡張的用途] で、ユースケースに応じて次のオプションを選択します。
- クライアント TLS: これらの証明書を使用すると、リクエスト元の ID を認証できます。
- サーバー TLS: これらの証明書を使用すると、サーバーの ID を認証できます。
[次へ] をクリックします。

鍵サイズとアルゴリズムを構成する

省略可: [鍵のサイズとアルゴリズムを構成する] で、リストから署名鍵のサイズとアルゴリズムを選択します。この手順をスキップすると、SHA 256 ダイジェストを使用した RSASSA-PSS の 2048 ビットの鍵が使用されます。署名鍵とアルゴリズムの選択については、鍵アルゴリズムを選択するをご覧ください。
[証明書を生成] をクリックします。

署名済み証明書をダウンロードする

生成された証明書を表示するには、[証明書を表示] をクリックし、[表示] をクリックします。
省略可: PEM でエンコードされた証明書チェーンをダウンロードするには、[証明書チェーンをダウンロード] をクリックします。
省略可: 関連付けられた PEM でエンコードされた秘密鍵をダウンロードするには、[秘密鍵をダウンロード] をクリックします。

重要: このページから移動すると、この鍵を取得できなくなります。このキーは機密情報です。鍵は安全な場所に保管することをおすすめします。
重要: DevOps CA プールを使用している場合、作成した証明書をダウンロードできるのはこの時点だけです。CA Service では、この画面以降、証明書の内容を保存しません。

gcloud

自動生成された鍵機能を使用するには、Python Cryptographic Authority（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: 1 つ以上のカンマ区切りの DNS サブジェクト代替名（SAN）。
CERTIFICATE_PROFILE: 証明書プロファイルの一意の識別子。たとえば、エンドエンティティサーバー TLS には leaf_server_tls を使用します。

gcloud コマンドでは、次のフラグを使用します。

--generate-key: マシンに新しい RSA-2048 秘密鍵を生成します。

次の任意のフラグの組み合わせを使用することもできます。

--dns-san: 1 つ以上のカンマ区切りの DNS SAN を渡すことができます。
--ip-san: 1 つ以上のカンマ区切りの IP SAN を渡すことができます。
--uri-san: 1 つ以上のカンマ区切りの 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


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

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 鍵を使用して証明書をリクエストする

Cloud KMS 鍵を使用して証明書のみをリクエストするには、Google Cloud CLI のみを使用できます。

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 から証明書を発行する方法について説明します。

Console

Google Cloud コンソールの [Certificate Authority Service] ページに移動します。

Certificate Authority Service に移動
[証明書をリクエスト] をクリックします。
リージョンを選択します。リージョンは、使用する CA プールのリージョンと同じである必要があります。
CA プールを選択します。
CA を選択するには、[この CA プールに含まれる特定の CA を使用する] をクリックして、リストから CA を選択します。
自動生成された鍵を使用して証明書をリクエストするセクションまたは CSR を使用して証明書をリクエストするセクションで行ったのと同様に、他のパラメータを選択します。

gcloud

証明書の発行のために CA プール内の特定の CA をターゲットにするには、証明書を発行する必要がある CA の CA_ID と一緒に --ca フラグを追加します。

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 エンコードされておらず、料金は発生しません。証明書はダウンロードできませんが、架空の証明書の説明で、選択したパラメータで署名付き証明書を正常に発行したことを確認できます。

検証モードで証明書をリクエストする手順は次のとおりです。

Console

Google Cloud コンソールの [Certificate Authority Service] ページに移動します。

Certificate Authority Service に移動
[証明書をリクエスト] をクリックします。
[署名済み証明書ではなく、仮の証明書の内容を表示する検証モードを使用する] を選択します。
署名付き証明書をリクエストする場合と同じ手順を行います。

次のステップ

証明書プロファイルについて学習する。
証明書を取り消す方法を学習する。
証明書の並べ替えとフィルタリング方法を学習する。
Google Cloud CLI を使用して証明書を管理する方法を確認する。

証明書をリクエスト

始める前に

CSR を使用して証明書をリクエストする

CSR を生成する

CSR を使用して証明書リクエストを送信する

Console

gcloud

Terraform

REST API

curl（Linux、macOS、Cloud Shell）

PowerShell（Windows）

自動生成された鍵を使用して証明書をリクエストする

Console

gcloud

Go

Java

Python

既存の Cloud KMS 鍵を使用して証明書をリクエストする

gcloud

CA プール内の特定の CA から証明書を発行する

Console

gcloud

Terraform

検証モードで証明書をリクエストする

Console

次のステップ