יצירת רשות אישורים משנית

בדף הזה מוסבר איך ליצור רשויות משנה להנפקת אישורים (CA) במאגר רשויות להנפקת אישורים.

רשויות אישורים משניות אחראיות להנפקת אישורים ישירות לישויות קצה כמו משתמשים, מחשבים ומכשירים. רשויות אישורים משניות חתומות באופן קריפטוגרפי על ידי רשות אישורים ראשית, שהיא בדרך כלל רשות האישורים הבסיסית. כתוצאה מכך, מערכות שסומכות על רשות האישורים הבסיסית סומכות באופן אוטומטי על רשויות האישורים המשניות ועל אישורי ישות הקצה שרשויות האישורים המשניות מנפיקות.

לפני שמתחילים

• מוודאים שיש לכם את תפקיד ה-IAM‏ "מנהל תפעול של שירות CA" ‏(roles/privateca.caManager) או "אדמין של שירות CA" ‏(roles/privateca.admin). למידע נוסף, קראו את המאמר הגדרת מדיניות IAM.
• יצירת מאגר CA.
• בוחרים את רשות האישורים הבסיסית.
• אם במאגר רשויות ה-CA שמכיל את רשות ה-CA הבסיסית המנפיקה מוגדרת מדיניות הנפקת אישורים, צריך לוודא שה-baselineValues שלה מאפשרים הנפקת אישורי CA מסוג caOptions.isCa: true,‏ keyUsage.baseKeyUsage.certSign: true ו-keyUsage.baseKeyUsage.crlSign: true. אחרת, הפעלת רשות האישורים המשנית תיכשל ותופיע הודעת השגיאה Fields in the CSR were modified or removed in the signed CA certificate.

יצירת רשות אישורים משנית

קל יותר לבטל ולהחליף רשויות אישורים משניות מאשר רשויות אישורים בסיסיות. אם יש לכם כמה תרחישים של הנפקת אישורים, אתם יכולים ליצור רשות אישורים משנית לכל אחד מהתרחישים האלה. הוספה של כמה רשויות אישורים משניות למאגר רשויות להנפקת אישורים (CA) עוזרת לאזן טוב יותר את העומסים של בקשות האישורים, ולהגדיל את מספר השאילתות האפקטיביות לשנייה (QPS).

כדי ליצור רשות אישורים משנית:

המסוף

1. נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

   כניסה ל-Certificate Authority Service

2. לוחצים על הכרטיסייה מנהל CA.

3. לוחצים על Create CA.

   

בחירת סוג רשות האישורים

1. לוחצים על רשות אישורים משנית.
2. לוחצים על Root CA is in Google Cloud.
3. בשדה Valid for, מזינים את משך הזמן שבו אישור ה-CA יהיה בתוקף.
4. אופציונלי: בוחרים את הרמה של רשות האישורים. רמת ברירת המחדל היא Enterprise. מידע נוסף זמין במאמר בחירת רמות הפעולה.
5. לוחצים על Region כדי לבחור מיקום ל-CA. מידע נוסף זמין במאמר מיקומים.
6. אופציונלי: בקטע Initialized state, בוחרים את המצב התפעולי שבו רוצים ליצור את ה-CA.
7. אופציונלי: בקטע Set up an issuance scenario, לוחצים על Certificate profile ובוחרים מהרשימה את פרופיל האישור שהכי מתאים לדרישות שלכם. מידע נוסף זמין במאמר פרופילים של אישורים.
8. לוחצים על הבא.

הגדרת שם הנושא של רשות האישורים

1. אופציונלי: בשדה Organization (O), מזינים את שם החברה.
2. אופציונלי: בשדה Organization unit (OU), מזינים את היחידה העסקית או את חטיבת המשנה של החברה.
3. אופציונלי: בשדה שם המדינה (C), מזינים קוד מדינה בן שתי אותיות.
4. אופציונלי: בשדה State or province name, מזינים את שם המדינה.
5. אופציונלי: בשדה Locality name, מזינים את שם העיר.
6. בשדה השם הנפוץ (CN) של רשות האישורים, מזינים את שם רשות האישורים.
7. לוחצים על Continue.

הגדרת גודל המפתח והאלגוריתם של רשות האישורים

1. בוחרים את אלגוריתם המפתח שהכי מתאים לצרכים שלכם. לפרטים נוספים על אפשרויות של מפתחות חתימה, ראו הגדרת מפתחות חתימה של CA.
2. כדי להשתמש במפתח חתימה בניהול הלקוח, בוחרים באפשרות Customer-managed key ומציינים את גרסת המפתח הקריפטוגרפי של Cloud Key Management Service.
3. לוחצים על Continue.

הגדרת פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) של רשות האישורים

1. בוחרים אם להשתמש בקטגוריה של Cloud Storage שמנוהלת על ידי Google או על ידי הלקוח.
1. בקטגוריה של Cloud Storage בניהול Google, שירות CA יוצר קטגוריה בניהול Google באותו מיקום של ה-CA.
2. בקטגוריה של Cloud Storage בניהול הלקוח, לוחצים על Browse ובוחרים באחת מהקטגוריות הקיימות של Cloud Storage.
2. לוחצים על Continue.

הוספת תוויות

השלבים הבאים הם אופציונליים.

כדי להוסיף תוויות ל-CA:

1. לוחצים על הוספת פריט.
2. בשדה מפתח 1, מזינים את מפתח התווית.
3. בשדה ערך 1, מזינים את ערך התווית.
4. אם רוצים להוסיף עוד תווית, לוחצים על Add item. לאחר מכן, מוסיפים את המפתח והערך של התווית, כמו שמתואר בשלבים 2 ו-3.
5. לוחצים על Continue.

בדיקת ההגדרות

בודקים היטב את כל ההגדרות ולוחצים על Done כדי ליצור את ה-CA.

gcloud

1. יוצרים מאגר רשויות להנפקת אישורים (CA) בשביל רשות האישורים המשנית:

   gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
   

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫SUBORDINATE_POOL_ID: שם מאגר ה-CA
   • ‫LOCATION: המיקום שבו רוצים ליצור את מאגר ה-CA. לרשימה המלאה של המיקומים, ראו מיקומים.

   מידע נוסף על יצירת מאגרי CA זמין במאמר יצירת מאגר CA.

   למידע נוסף על הפקודה gcloud privateca pools create, ראו gcloud privateca pools create.

2. יוצרים רשות אישורים משנית במאגר רשויות להנפקת אישורים (CA) שנוצר.

   הערה: כדי לקבל את מזהה המשאב של המנפיק (ISSUER_POOL_ID), אפשר להעתיק את המזהה מהפקודה create או להשתמש בפקודה gcloud privateca pools list.

   חשוב לוודא שבשדה --issuer-pool מצוין המזהה של מאגר ה-CA המנפיק (ולא מזהה המשאב של ה-CA ברמה הבסיסית). בנוסף, אם במאגר ה-CA המנפיק מוגדרת מדיניות הנפקה, ה-baselineValues שלו צריך לאפשר אישורי CA:

   baselineValues:
     caOptions:
       isCa: true
     keyUsage:
       baseKeyUsage:
         certSign: true
         crlSign: true
   

   אם מאגר רשויות להנפקת אישורים (CA) המנפיקות מגביל את ההנפקה לאישורים של ישויות קצה, הפעלת רשות אישורים משנית תיכשל ותופיע הודעת השגיאה Fields in the CSR were modified or removed in the signed CA certificate.

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫SUBORDINATE_CA_ID: המזהה הייחודי של רשות האישורים המשנית
   • ‫SUBORDINATE_POOL_ID: שם מאגר ה-CA
   • ‫LOCATION: המיקום של מאגר ה-CA
   • ‫ISSUER_POOL_ID: שם מאגר ה-CA שמכיל את ה-CA המנפיקה

   • ‫ISSUER_LOCATION: המיקום של מאגר ה-CA שמכיל את ה-CA המנפיקה

     הדגל --key-algorithm מציין את האלגוריתם הקריפטוגרפי שבו רוצים להשתמש כדי ליצור מפתח Cloud HSM מנוהל ל-CA.

     הדגל --subject מציין את שם ה-X.501 של נושא האישור.

   כדי ליצור רשות אישורים משנית באמצעות מפתח חתימה בניהול הלקוח, מריצים את הפקודה הבאה:

   gcloud privateca subordinates create SUBORDINATE_CA_ID \
       --pool=SUBORDINATE_POOL_ID \
       --location=LOCATION \
       --issuer-pool=ISSUER_POOL_ID \
       --issuer-location=ISSUER_LOCATION \
       --kms-key-version=KMS_KEY_VERSION \
       --subject="CN=Example Server TLS CA, O=Example LLC"
   

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫SUBORDINATE_POOL_ID: שם מאגר ה-CA
   • ‫LOCATION: המיקום של מאגר ה-CA
   • ‫ISSUER_POOL_ID: שם מאגר ה-CA שמכיל את ה-CA המנפיקה
   • ‫ISSUER_LOCATION: המיקום של מאגר ה-CA שמכיל את ה-CA המנפיקה
   • ‫KMS_KEY_VERSION: מזהה המשאב המלא של גרסת המפתח הקריפטוגרפי ב-Cloud KMS, שמנוהל על ידי הלקוח ומשמש כמפתח החתימה

   לפרטים נוספים על האפשרויות של מפתחות החתימה ועל הכנת מפתח חתימה בניהול הלקוח, ראו הגדרת מפתחות חתימה של CA.

   ההצהרה הבאה מוחזרת כשנוצרת רשות האישורים המשנית.

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

   כדי לציין כתובות URL מותאמות אישית לגישה ל-Authority Information Access ‏ (AIA) ול-CRL Distribution Point ‏ (CDP), משתמשים בדגלים --custom-aia-urls ו---custom-cdp-urls. אם מציינים כתובות URL, הן נכללות בכל האישורים שהונפקו על ידי ה-CA ומחליפות את כתובות ה-URL שמוגדרות כברירת מחדל לגישה לקטגוריות של Cloud Storage.

   כדי לראות רשימה מלאה של ההגדרות, מריצים את הפקודה הבאה של gcloud:

   gcloud privateca subordinates create --help
   

   הפקודה מחזירה דוגמאות ליצירת רשות אישורים משנית שהמנפיק שלה נמצא ב-CA Service או במקום אחר.

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, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

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, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

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

הפעלה של רשות אישורים משנית

כדי להפעיל רשות אישורים משנית:

המסוף

1. נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

   כניסה ל-Certificate Authority Service

2. לוחצים על הכרטיסייה מנהל CA.

3. בקטע Certificate authorities, בוחרים את רשות האישורים שרוצים להפעיל.

4. לוחצים על play_circleEnable.

gcloud

כדי להפעיל רשות אישורים משנית חדשה, מריצים את הפקודה הבאה:

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

מחליפים את מה שכתוב בשדות הבאים:

• ‫SUBORDINATE_CA_ID: המזהה הייחודי של רשות האישורים המשנית
• ‫SUBORDINATE_POOL_ID: השם של מאגר ה-CA שמכיל את רשות האישורים המשנית
• ‫LOCATION: המיקום של מאגר ה-CA. לרשימת המיקומים המלאה

מידע נוסף על הפקודה gcloud privateca subordinates enable זמין במאמר gcloud privateca subordinates enable.

Terraform

מגדירים את השדה desired_state לערך ENABLED ברשות האישורים המשנית ומריצים את הפקודה terraform apply.

Java

כדי להפעיל את רשות האישורים המשנית באמצעות אישור חתום, צריך להפעיל את ה-RPC‏ ActivateCertificateAuthority:

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.ActivateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.SubordinateConfig;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class ActivateSubordinateCa {

  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 a unique id for the CA pool.
    // subordinateCaName: The CA to be activated.
    // pemCaCertificate: The signed certificate, obtained by signing the CSR.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";
    String pemCaCertificate =
        "-----BEGIN CERTIFICATE-----\n" + "sample-pem-certificate\n" + "-----END CERTIFICATE-----";

    // certificateAuthorityName: The name of the certificate authority which signed the CSR.
    // If an external CA (CA not present in Google Cloud) was used for signing,
    // then use the CA's issuerCertificateChain.
    String certificateAuthorityName = "certificate-authority-name";

    activateSubordinateCa(
        project, location, poolId, certificateAuthorityName, subordinateCaName, pemCaCertificate);
  }

  // Activate a subordinate CA.
  // *Prerequisite*: Get the CSR of the subordinate CA signed by another CA. Pass in the signed
  // certificate and (issuer CA's name or the issuer CA's Certificate chain).
  // *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
  public static void activateSubordinateCa(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String subordinateCaName,
      String pemCaCertificate)
      throws ExecutionException, InterruptedException, 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()) {
      // Subordinate CA parent.
      String subordinateCaParent =
          CertificateAuthorityName.of(project, location, poolId, subordinateCaName).toString();

      // Construct the "Activate CA Request".
      ActivateCertificateAuthorityRequest activateCertificateAuthorityRequest =
          ActivateCertificateAuthorityRequest.newBuilder()
              .setName(subordinateCaParent)
              // The signed certificate.
              .setPemCaCertificate(pemCaCertificate)
              .setSubordinateConfig(
                  SubordinateConfig.newBuilder()
                      // Follow one of the below methods:

                      // Method 1: If issuer CA is in Google Cloud, set the Certificate Authority
                      // Name.
                      .setCertificateAuthority(
                          CertificateAuthorityName.of(
                                  project, location, poolId, certificateAuthorityName)
                              .toString())

                      // Method 2: If issuer CA is external to Google Cloud, set the issuer's
                      // certificate chain.
                      // The certificate chain of the CA (which signed the CSR) from leaf to root.
                      // .setPemIssuerChain(
                      //     SubordinateConfigChain.newBuilder()
                      //         .addAllPemCertificates(issuerCertificateChain)
                      //         .build())

                      .build())
              .build();

      // Activate the CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .activateCertificateAuthorityCallable()
              .futureCall(activateCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while activating the subordinate CA! " + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority activated successfully ! !" + subordinateCaName);
      TimeUnit.SECONDS.sleep(3);
      // The current state will be STAGED.
      // The Subordinate CA has to be ENABLED before issuing certificates.
      System.out.println(
          "Current State: "
              + certificateAuthorityServiceClient
              .getCertificateAuthority(subordinateCaParent)
              .getState());
    }
  }
}

כדי להפעיל את רשות האישורים המשנית כך שתוכל להנפיק אישורים, צריך להפעיל את ה-RPC של EnableCertificateAuthority:

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CertificateAuthority.State;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.EnableCertificateAuthorityRequest;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class EnableCertificateAuthority {

  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: The id of the CA pool under which the CA is present.
    // certificateAuthorityName: The name of the CA to be enabled.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    enableCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Enable the Certificate Authority present in the given ca pool.
  // CA cannot be enabled if it has been already deleted.
  public static void enableCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws IOException, ExecutionException, InterruptedException {
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {
      // Create the Certificate Authority Name.
      CertificateAuthorityName certificateAuthorityParent =
          CertificateAuthorityName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .setCertificateAuthority(certificateAuthorityName)
              .build();

      // Create the Enable Certificate Authority Request.
      EnableCertificateAuthorityRequest enableCertificateAuthorityRequest =
          EnableCertificateAuthorityRequest.newBuilder()
              .setName(certificateAuthorityParent.toString())
              .build();

      // Enable the Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .enableCertificateAuthorityCallable()
              .futureCall(enableCertificateAuthorityRequest);
      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while enabling Certificate Authority !" + response.getError());
        return;
      }

      // Get the current CA state.
      State caState =
          certificateAuthorityServiceClient
              .getCertificateAuthority(certificateAuthorityParent)
              .getState();

      // Check if the CA is enabled.
      if (caState == State.ENABLED) {
        System.out.println("Enabled Certificate Authority : " + certificateAuthorityName);
      } else {
        System.out.println(
            "Cannot enable the Certificate Authority ! Current CA State: " + caState);
      }
    }
  }
}

Python

כדי להפעיל את רשות האישורים המשנית באמצעות אישור חתום, צריך להפעיל את ה-RPC‏ ActivateCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def activate_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    pem_ca_certificate: str,
    ca_name: str,
) -> None:
    """
    Activate a subordinate Certificate Authority (CA).
    *Prerequisite*: Get the Certificate Signing Resource (CSR) of the subordinate CA signed by another CA. Pass in the signed
    certificate and (issuer CA's name or the issuer CA's Certificate chain).
    *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
    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.
        pem_ca_certificate: the signed certificate, obtained by signing the CSR.
        subordinate_ca_name: the CA to be activated.
        ca_name: The name of the certificate authority which signed the CSR.
            If an external CA (CA not present in Google Cloud) was used for signing,
            then use the CA's issuerCertificateChain.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    subordinate_ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, subordinate_ca_name
    )
    ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Set CA subordinate config.
    subordinate_config = privateca_v1.SubordinateConfig(
        # Follow one of the below methods:
        # Method 1: If issuer CA is in Google Cloud, set the Certificate Authority Name.
        certificate_authority=ca_path,
        # Method 2: If issuer CA is external to Google Cloud, set the issuer's certificate chain.
        # The certificate chain of the CA (which signed the CSR) from leaf to root.
        # pem_issuer_chain=privateca_v1.SubordinateConfig.SubordinateConfigChain(
        #     pem_certificates=issuer_certificate_chain,
        # )
    )

    # Construct the "Activate CA Request".
    request = privateca_v1.ActivateCertificateAuthorityRequest(
        name=subordinate_ca_path,
        # The signed certificate.
        pem_ca_certificate=pem_ca_certificate,
        subordinate_config=subordinate_config,
    )

    # Activate the CA
    operation = ca_service_client.activate_certificate_authority(request=request)
    result = operation.result()

    print("Operation result:", result)

    # The current state will be STAGED.
    # The Subordinate CA has to be ENABLED before issuing certificates.
    print(
        f"Current state: {ca_service_client.get_certificate_authority(name=subordinate_ca_path).state}"
    )

כדי להפעיל את רשות האישורים המשנית כך שתוכל להנפיק אישורים, צריך להפעיל את ה-RPC של EnableCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def enable_certificate_authority(
    project_id: str, location: str, ca_pool_name: str, ca_name: str
) -> None:
    """
    Enable the Certificate Authority present in the given ca pool.
    CA cannot be enabled if it has been already deleted.

    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: the name of the CA pool under which the CA is present.
        ca_name: the name of the CA to be enabled.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()
    ca_path = caServiceClient.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Create the Enable Certificate Authority Request.
    request = privateca_v1.EnableCertificateAuthorityRequest(
        name=ca_path,
    )

    # Enable the Certificate Authority.
    operation = caServiceClient.enable_certificate_authority(request=request)
    operation.result()

    # Get the current CA state.
    ca_state = caServiceClient.get_certificate_authority(name=ca_path).state

    # Check if the CA is enabled.
    if ca_state == privateca_v1.CertificateAuthority.State.ENABLED:
        print("Enabled Certificate Authority:", ca_name)
    else:
        print("Cannot enable the Certificate Authority ! Current CA State:", ca_state)

הערה: שירות CA לא בודק את סטטוס הביטול של רשות האישורים ברמה הבסיסית (root) לפני שהוא מפעיל רשות אישורים משנית שמשורשרת אליה. החריג היחיד למדיניות הזו הוא אם יצרתם את ה-CA ברמה הבסיסית באמצעות שירות CA. בתרחיש הזה, שירות CA בודק מדי יום את סטטוס הביטול של ה-CA הבסיסי. אם רשות האישורים הבסיסית בוטלה, שירות ה-CA מעדכן את המדד privateca.googleapis.com/ca/cert_revoked ברשות האישורים המשנית.

המאמרים הבאים

• איך מבקשים אישורים
• איך שולחים בקשה לאישור באמצעות CSR
• מידע נוסף על תבניות וכללי מדיניות להנפקה