Crea un'autorità di certificazione radice

Questa pagina descrive come creare un'autorità di certificazione (CA) radice in un pool di CA.

Una CA principale si trova nella parte superiore di una gerarchia di infrastruttura a chiave pubblica (PKI) ed è responsabile della formazione del trust anchor della PKI. Per partecipare e utilizzare correttamente i certificati in una PKI, un dispositivo, un software o un componente deve considerare attendibile la PKI. Ciò viene ottenuto configurando il dispositivo, il software o il componente in modo che attenda la CA radice. Di conseguenza, tutti i certificati emessi dalla CA radice sono attendibili.

Prima di iniziare

Crea una CA radice

Un'autorità di certificazione radice ha un certificato autofirmato che devi distribuire agli archivi chiavi attendibili dei tuoi client. Il certificato della CA radice si trova nella parte superiore della catena di certificati. Nessun'altra CA può revocare il certificato CA. La CRL della CA radice si applica solo agli altri certificati emessi dalla CA radice, ma non a se stessa.

Console

Per creare una CA radice:

  1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

    Vai a Certificate Authority Service

  2. Fai clic sulla scheda Gestore CA.

  3. Fai clic su Crea CA.

Seleziona il tipo di CA

Per configurare le impostazioni permanenti della CA, ad esempio il livello, la posizione, la durata e lo stato operativo al momento della creazione, svolgi i seguenti passaggi:

  1. Seleziona CA radice.
  2. Nel campo Valido per, inserisci la durata per la quale vuoi che i certificati emessi dal certificato CA siano validi.
  3. (Facoltativo) Seleziona un livello per la CA.
  4. Fai clic su Regione e nell'elenco seleziona la località in cui vuoi creare la CA. Ti consigliamo di creare la CA geograficamente vicino ai clienti della tua applicazione. Per ulteriori informazioni, consulta la sezione Scegliere la migliore posizione.

  5. (Facoltativo) Seleziona lo stato operativo dell'autorità di certificazione da creare.

    Scegli lo stato di funzionamento dell'autorità di certificazione da creare.

  6. (Facoltativo) Fai clic su Profilo certificato. Nell'elenco, seleziona il profilo di certificato corrispondente al tipo di certificati che vuoi che l' autorità di certificazione emetta.

  7. Fai clic su Avanti.

Configura il nome oggetto della CA
  1. Nel campo Organizzazione (O), inserisci il nome della tua azienda.
  2. (Facoltativo) Nel campo Unità organizzativa (OU), inserisci la suddivisione dell'azienda o la business unit.
  3. (Facoltativo) Nel campo Nome paese, inserisci un codice paese di due lettere.
  4. (Facoltativo) Nel campo Nome stato o provincia, inserisci il nome del tuo stato.
  5. (Facoltativo) Nel campo Nome località, inserisci il nome della tua città.
  6. Nel campo Nome comune CA (CN), inserisci il nome della CA.
  7. Nel campo ID pool, inserisci il nome del pool di CA. Non puoi modificare il pool di CA dopo aver creato la CA.
  8. Fai clic su Avanti.
Configura dimensioni e algoritmo della chiave CA
  1. Scegli l'algoritmo chiave più adatto alle tue esigenze. Per informazioni su come scegliere l'algoritmo chiave più adatto, consulta Scegliere un algoritmo chiave.
  2. Fai clic su Avanti.
Configurare gli elementi CA

I passaggi che seguono sono facoltativi. Se salti questi passaggi, verranno applicate le impostazioni predefinite.

  1. Scegli se utilizzare un bucket Cloud Storage gestito da Google o autogestito.

    2. Se non selezioni un bucket Cloud Storage autogestito, il servizio CA crea un bucket gestito da Google nella stessa posizione dell'autorità di certificazione.

  2. Scegli se disattivare la pubblicazione degli elenchi di revoche dei certificati (CRL) e dei certificati CA nel bucket Cloud Storage.

    3. La pubblicazione di CRL e certificato CA in un bucket Cloud Storage è abilitata per impostazione predefinita. Per disattivare queste impostazioni, fai clic sui pulsanti di attivazione/disattivazione.

  3. Fai clic su Avanti.
Aggiungere etichette

I passaggi che seguono sono facoltativi.

Se vuoi aggiungere etichette alla CA:

  1. Fai clic su Aggiungi elemento.
  2. Nel campo Chiave 1, inserisci la chiave dell'etichetta.
  3. Nel campo Valore 1, inserisci il valore dell'etichetta.
  4. Se vuoi aggiungere un'altra etichetta, fai clic su Aggiungi elemento. Aggiungi poi la chiave e il valore dell'etichetta come indicato nei passaggi 2 e 3.
  5. Fai clic su Avanti.
Rivedi le impostazioni

Esamina attentamente tutte le impostazioni, quindi fai clic su Crea per creare la CA.

gcloud

  1. Per creare un pool di CA, esegui il seguente comando:

    gcloud privateca pools create POOL_ID

    Sostituisci POOL_ID con il nome del pool di CA.

    Per ulteriori informazioni, vedi Creare un pool di CA.

    Per ulteriori informazioni su questo comando gcloud, consulta gcloud privateca pools create.

  2. Crea una nuova CA radice nel pool di CA che hai creato.

    gcloud privateca roots create ROOT_CA_ID --pool=POOL_ID \
  --key-algorithm=KEY_ALGORITHM \
  --subject="CN=my-ca, O=Test LLC"

    Sostituisci quanto segue:

    • ROOT_CA_ID: il nome della CA.
    • POOL_ID: il nome del pool di CA.
    • KEY_ALGORITHM: l'algoritmo da utilizzare per creare una chiave Cloud KMS. Questo flag è facoltativo. Se non includi questo flag, l'algoritmo principale predefinito è rsa-pkcs1-4096-sha256. Per maggiori informazioni, consulta il flag --key-algorithm.

    Per impostazione predefinita, la CA viene creata nello stato STAGED. Per attivare una CA per impostazione predefinita, includi il flag --auto-enable.

    Se vuoi utilizzare un bucket Cloud Storage gestito dal cliente per la pubblicazione di certificati CA e CRL, aggiungi --bucket bucket-name al comando. Sostituisci bucket-name con il nome del bucket Cloud Storage.

    Per visualizzare l'elenco completo delle impostazioni, esegui il seguente comando:

    gcloud privateca roots create --help

Terraform

Per creare una CA radice utilizzando una chiave di proprietà e gestita da Google, utilizza la seguente configurazione di esempio:

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

Per creare una CA radice utilizzando una chiave gestita autonomamente, utilizza la seguente configurazione di esempio:

resource "google_project_service_identity" "privateca_sa" {
  provider = google-beta
  service  = "privateca.googleapis.com"
}

resource "google_kms_crypto_key_iam_binding" "privateca_sa_keyuser_signerverifier" {
  crypto_key_id = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key"
  role          = "roles/cloudkms.signerVerifier"

  members = [
    "serviceAccount:${google_project_service_identity.privateca_sa.email}",
  ]
}

resource "google_kms_crypto_key_iam_binding" "privateca_sa_keyuser_viewer" {
  crypto_key_id = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key"
  role          = "roles/viewer"
  members = [
    "serviceAccount:${google_project_service_identity.privateca_sa.email}",
  ]
}

resource "google_privateca_certificate_authority" "default" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "ca-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  key_spec {
    cloud_kms_key_version = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key/cryptoKeyVersions/1"
  }

  config {
    subject_config {
      subject {
        organization = "Example, Org."
        common_name  = "Example Authority"
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca                  = true
        max_issuer_path_length = 10
      }
      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
        }
      }
    }
  }

  depends_on = [
    google_kms_crypto_key_iam_binding.privateca_sa_keyuser_signerverifier,
    google_kms_crypto_key_iam_binding.privateca_sa_keyuser_viewer,
  ]
}

Vai

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 Certificate Authority which is the root CA in the given CA Pool. This CA will be
// responsible for signing certificates within this pool.
func createCa(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	caCommonName string,
	org string,
	caDuration int64) 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 under which the CA should be created.
	// caId := "ca-id"					// A unique id/name for the ca.
	// caCommonName := "ca-name"		// A common name for your certificate authority.
	// org := "ca-org"					// The name of your company for your certificate authority.
	// ca_duration := int64(31536000)	// The validity of the certificate authority in seconds.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	// Set the types of Algorithm used to create a cloud KMS key.
	keySpec := &privatecapb.CertificateAuthority_KeyVersionSpec{
		KeyVersion: &privatecapb.CertificateAuthority_KeyVersionSpec_Algorithm{
			Algorithm: privatecapb.CertificateAuthority_RSA_PKCS1_2048_SHA256,
		},
	}

	// Set CA subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName:   caCommonName,
			Organization: org,
		},
	}

	// Set the key usage options for X.509 fields.
	isCa := true
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				CrlSign:  true,
				CertSign: true,
			},
		},
		CaOptions: &privatecapb.X509Parameters_CaOptions{
			IsCa: &isCa,
		},
	}

	// Set certificate authority settings.
	// Type: SELF_SIGNED denotes that this CA is a root CA.
	ca := &privatecapb.CertificateAuthority{
		Type:    privatecapb.CertificateAuthority_SELF_SIGNED,
		KeySpec: keySpec,
		Config: &privatecapb.CertificateConfig{
			SubjectConfig: subjectConfig,
			X509Config:    x509Parameters,
		},
		Lifetime: &durationpb.Duration{
			Seconds: caDuration,
		},
	}

	fullCaPoolName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the CreateCertificateAuthorityRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateAuthorityRequest.
	req := &privatecapb.CreateCertificateAuthorityRequest{
		Parent:                 fullCaPoolName,
		CertificateAuthorityId: caId,
		CertificateAuthority:   ca,
	}

	op, err := caClient.CreateCertificateAuthority(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCertificateAuthority failed: %w", err)
	}

	if _, err = op.Wait(ctx); err != nil {
		return fmt.Errorf("CreateCertificateAuthority failed during wait: %w", err)
	}

	fmt.Fprintf(w, "CA %s created", caId)

	return nil
}

Java

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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.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 CreateCertificateAuthority {

  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.
    // certificateAuthorityName: Unique name for the CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    createCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Create Certificate Authority which is the root CA in the given CA Pool.
  public static void createCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      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()) {

      String commonName = "common-name";
      String orgName = "org-name";
      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())
              .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 certificateAuthority =
          CertificateAuthority.newBuilder()
              // CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
              .setType(CertificateAuthority.Type.SELF_SIGNED)
              .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 certificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(certificateAuthorityName)
              .setCertificateAuthority(certificateAuthority)
              .build();

      // Create Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(certificateAuthorityRequest);
      Operation response = futureCall.get();

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

      System.out.println(
          "Certificate Authority created successfully : " + certificateAuthorityName);
    }
  }
}

Python

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_certificate_authority(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    common_name: str,
    organization: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority which is the root CA in the given CA Pool. This CA will be
    responsible for signing certificates within this 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.
        ca_name: unique name for the CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # Set the types of Algorithm used to create a cloud KMS key.
    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 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(
        # CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
        type_=privateca_v1.CertificateAuthority.Type.SELF_SIGNED,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

    ca_pool_path = caServiceClient.ca_pool_path(project_id, location, ca_pool_name)

    # Create the CertificateAuthorityRequest.
    request = privateca_v1.CreateCertificateAuthorityRequest(
        parent=ca_pool_path,
        certificate_authority_id=ca_name,
        certificate_authority=certificate_authority,
    )

    operation = caServiceClient.create_certificate_authority(request=request)
    result = operation.result()

    print("Operation result:", result)

API REST

  1. Crea una CA radice.

    Metodo HTTP e URL: 

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities?certificate_authority_id=ROOT_CA_ID

    Corpo JSON della richiesta: 

    {
"type": "SELF_SIGNED",
"lifetime": {
 "seconds": 315576000,
 "nanos": 0
},
"config": {
 "subject_config": {
   "subject": {
     "organization": "ORGANIZATION_NAME",
     "common_name": "COMMON_NAME"
   }
 },
 "x509_config":{
   "ca_options":{
     "is_ca":true
   },
   "key_usage":{
     "base_key_usage":{
       "cert_sign":true,
       "crl_sign":true
     }
   }
 }
},
"key_spec":{
 "algorithm":"RSA_PKCS1_4096_SHA256"
}
}

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
 "metadata": {...},
 "done": false
}

  2. Effettua il polling dell'operazione fino al completamento.

    Metodo HTTP e URL: 

    GET https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
 "metadata": {...},
 "done": true,
 "response": {
   "@type": "type.googleapis.com/google.cloud.security.privateca.v1.CertificateAuthority",
   "name": "...",
 }
}

Dopo aver verificato che l'AC funzioni come previsto, puoi attivarla per iniziare a emettere certificati con bilanciamento del carico per il pool di CA.

Attivare una CA radice

gcloud

Per abilitare una CA principale, esegui il seguente comando gcloud:

gcloud privateca roots enable ROOT_CA_ID --pool=POOL_ID

Sostituisci quanto segue:

  • ROOT_CA_ID: il nome della CA.
  • POOL_ID: il nome del pool di CA.

Terraform

Se utilizzi Terraform per creare una CA radice, questa viene attivata al momento della creazione. Per creare una CA radice nello stato STAGED, imposta il campo desired_state su STAGED durante la creazione della CA.

Puoi impostare il campo desired_state su ENABLED o DISABLED dopo la creazione dell'APV.

Vai

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
)

// Enable the Certificate Authority present in the given ca pool.
// CA cannot be enabled if it has been already deleted.
func enableCa(w io.Writer, projectId string, location string, caPoolId string, caId string) 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 id of the CA pool under which the CA is present.
	// caId := "ca-id"				// The id of the CA to be enabled.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	fullCaName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s/certificateAuthorities/%s",
		projectId, location, caPoolId, caId)

	// Create the EnableCertificateAuthorityRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#EnableCertificateAuthorityRequest.
	req := &privatecapb.EnableCertificateAuthorityRequest{Name: fullCaName}

	op, err := caClient.EnableCertificateAuthority(ctx, req)
	if err != nil {
		return fmt.Errorf("EnableCertificateAuthority failed: %w", err)
	}

	var caResp *privatecapb.CertificateAuthority
	if caResp, err = op.Wait(ctx); err != nil {
		return fmt.Errorf("EnableCertificateAuthority failed during wait: %w", err)
	}

	if caResp.State != privatecapb.CertificateAuthority_ENABLED {
		return fmt.Errorf("unable to enable Certificate Authority. Current state: %s", caResp.State.String())
	}

	fmt.Fprintf(w, "Successfully enabled Certificate Authority: %s.", caId)
	return nil
}

Java

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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)

API REST

  1. Consenti all'autorità di certificazione di emettere certificati dal pool di CA.

    Metodo HTTP e URL: 

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
 "metadata": {...},
 "done": false
}

  2. Effettua il polling dell'operazione fino al completamento.

    Metodo HTTP e URL: 

    GET https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
 "metadata": {...},
 "done": true,
 "response": {
   "@type": "type.googleapis.com/google.cloud.security.privateca.v1.CertificateAuthority",
   "name": "...",
 }
}

Testare una CA

Per verificare che un'autorità di certificazione sia in grado di emettere certificati, richiedi un certificato al pool di CA associato e menziona esplicitamente il nome dell'autorità di certificazione che vuoi testare utilizzando il flag --ca.

Per richiedere un certificato da un pool di CA, puoi utilizzare i seguenti metodi:

  1. Chiedi al servizio CA di creare una chiave privata o pubblica per te.
  2. Genera la tua chiave privata o pubblica e invia una richiesta di firma del certificato (CSR).

È più facile utilizzare una chiave privata o una chiave pubblica generata automaticamente per richiedere un certificato a una CA in un pool di CA. Questa sezione fornisce informazioni su come testare una CA utilizzando questo metodo.

Per utilizzare una chiave privata o pubblica generata automaticamente per richiedere un certificato da un'autorità di certificazione in un pool di CA, esegui il seguente comando gcloud:

gcloud privateca certificates create \
  --issuer-pool=POOL_ID \
  --ca=ROOT_CA_ID \
  --generate-key \
  --key-output-file=KEY_FILENAME \
  --cert-output-file=CERT_FILENAME \
  --dns-san=DNS_NAME

Sostituisci quanto segue:

  • POOL_ID: il nome del pool di CA.
  • ROOT_CA_ID: l'identificatore univoco della CA che vuoi testare.
  • KEY_FILENAME: il file in cui la chiave generata è scritta in formato PEM.
  • CERT_FILENAME: il file in cui viene scritto il file della catena di certificati con codifica PEM risultante. L'ordine della catena di certificati è dal certificato dell'entità finale a quello radice.

  • DNS_NAME: uno o più nomi DNS alternativi dell'oggetto (SAN) separati da virgole.

    Il flag --generate-key genera una nuova chiave privata RSA-2048 sul tuo computer.

Per utilizzare una richiesta di firma del certificato (CSR) per richiedere un certificato da un'autorità di certificazione in un pool di CA o per ulteriori informazioni sulla richiesta di certificati, consulta Richiedere un certificato e visualizzare i certificati emessi.

Clona le autorità di certificazione

Per clonare una CA esistente al fine di rinnovarla o per creare una nuova CA con la stessa configurazione, esegui il seguente comando:

gcloud privateca roots create NEW_CA_ID --pool=POOL_ID \
  --from-ca=EXISTING_CA_ID \
  --key-algorithm "ec-p384-sha384"

Sostituisci quanto segue:

  • NEW_CA_ID: l'identificatore univoco della nuova CA.
  • POOL_ID: il nome del pool di CA in cui vuoi creare la nuova CA.

Il flag --from-ca è supportato per la creazione di CA radice e subordinate. La CA esistente deve trovarsi nello stesso pool di CA della nuova CA.

Il flag --key-algorithm copia tutta la configurazione della CA dalla CA esistente (tranne la versione della chiave Cloud KMS e il bucket Cloud Storage). Tuttavia, puoi comunque sostituire qualsiasi valore di configurazione nel nuovo CA fornendo esplicitamente il flag appropriato. Ad esempio, puoi comunque specificare `--subject SUBJECT per utilizzare un nuovo oggetto.

Se ometti il flag --key-algorithm, l'algoritmo predefinito è:

  • rsa-pkcs1-4096-sha256 per le CA radice.
  • rsa-pkcs1-2048-sha256 per le CA subordinate.

Per ulteriori informazioni su questo comando gcloud, consulta gcloud privateca roots create.

Passaggi successivi