Crie uma AC raiz:

Nesta página, descrevemos como criar uma autoridade certificadora raiz (CA) em um pool de CAs.

Uma CA raiz está no topo de uma hierarquia de infraestrutura de chave pública (ICP) e é responsável por formar a âncora de confiança da ICP. Para participar e usar certificados corretamente em uma ICP, um dispositivo, software ou componente precisa confiar na ICP. Isso é feito configurando o dispositivo, o software ou o componente para confiar na CA raiz. Como resultado, todos os certificados emitidos pela AC raiz são confiáveis.

Antes de começar

• Verifique se você tem o papel do IAM de gerente de operações do serviço de AC (roles/privateca.caManager) ou administrador do serviço de AC (roles/privateca.admin). Para mais informações, consulte Configurar políticas do IAM.

• Se você usar uma chave do Cloud Key Management Service para assinar certificados emitidos pela AC, conceda os papéis do IAM necessários ao agente de serviço da CA nessa chave do Cloud Key Management Service. Para mais informações sobre as funções específicas necessárias e instruções, consulte Usar o agente de serviço da CA.

• Criar um pool de CA.

• Determine suas configurações de CA.

Crie uma AC raiz:

Uma CA raiz tem um certificado autoassinado que precisa ser distribuído para os repositórios de confiança dos clientes. O certificado da CA raiz está na parte superior da cadeia de certificados. Nenhuma outra AC pode revogar o certificado de CA. A CRL da CA raiz se aplica apenas aos outros certificados emitidos por ela, mas não a si mesma.

É possível criar uma AC raiz em um pool de CAs atual ou novo. As instruções a seguir usam um pool existente.

Console

Para criar uma CA raiz em um pool de CAs, faça o seguinte:

1. Acesse a página Serviço de autoridade certificadora no console doGoogle Cloud .

   Acesse Certificate Authority Service

2. Clique na guia Gerenciador de CA.

   Observação: não é possível criar mais de uma CA em um pool de CAs usando a guia Gerenciador de CAs.

3. Clique na seta de expansão Criar CA e selecione Criar CA em um pool de CAs atual.

Selecionar pool de CAs

Selecione um pool de CA na lista e clique em Continuar.

Selecione o tipo de CA

1. Em Tipo, selecione CA raiz.
2. No campo Válido por, insira a duração que você quer que os certificados emitidos pela CA raiz sejam válidos.
3. Em Estado inicializado, selecione o estado operacional para criar a CA.
4. Clique em Continuar.

Configurar o nome do assunto da CA

1. No campo Organização (O), insira o nome da sua empresa.
2. Opcional: no campo Unidade organizacional (UO), insira a subdivisão ou unidade de negócios da empresa.
3. Opcional: no campo Nome do país (C), insira um código de país de duas letras.
4. Opcional: no campo Nome do estado ou da província, insira o nome do seu estado.
5. Opcional: no campo Nome da localidade, insira o nome da sua cidade.
6. No campo Nome comum da CA (CN), insira o nome da CA.
7. Clique em Continuar.

Configurar o tamanho e o algoritmo da chave da CA

1. Escolha o algoritmo de chave que melhor atende às suas necessidades. Para mais detalhes sobre as opções de chave de assinatura, consulte Configurar chaves de assinatura da CA.
2. Para usar uma chave de assinatura gerenciada pelo cliente, selecione Chave gerenciada pelo cliente e forneça a versão da chave criptográfica do Cloud Key Management Service.
3. Clique em Continuar.

Configurar artefatos de CA

1. Escolha se você quer usar um bucket do Cloud Storage gerenciado pelo Google ou pelo cliente.
1. Para um bucket do Cloud Storage gerenciado pelo Google, o CA Service cria um bucket gerenciado pelo Google no mesmo local da CA.
2. Para um bucket do Cloud Storage gerenciado pelo cliente, clique em "Procurar" e selecione um dos buckets do Cloud Storage.
2. Clique em Continuar.

Adicionar rótulos

As etapas a seguir são opcionais.

Se você quiser adicionar rótulos à CA, faça o seguinte:

1. Clique em Adicionar item.
2. No campo Chave 1, insira a chave do rótulo.
3. No campo Valor 1, insira o valor do rótulo.
4. Se quiser adicionar outro rótulo, clique em Adicionar item. Em seguida, adicione a chave e o valor do rótulo, conforme mencionado nas etapas 2 e 3.
5. Clique em Continuar.

Revise as configurações

Revise todas as configurações com atenção e clique em Concluído para criar a CA.

gcloud

1. Para criar uma nova AC raiz em um pool de ACs, execute o seguinte comando:

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

   Substitua:

   • ROOT_CA_ID: o nome da CA.
   • LOCATION: o local do pool de ACs.
   • POOL_ID: o nome do pool de ACs.
   • KEY_ALGORITHM: o algoritmo a ser usado para criar uma chave do Cloud KMS. Essa sinalização é opcional. Se você não incluir essa flag, o algoritmo de chave será rsa-pkcs1-4096-sha256 por padrão. Para mais informações, consulte a flag --key-algorithm.

   Por padrão, a CA é criada no estado STAGED. Para ativar uma CA por padrão, inclua a flag --auto-enable.

   Se você quiser usar um bucket do Cloud Storage gerenciado pelo cliente para publicar certificados de CA e CRLs, adicione --bucket bucket-name ao comando. Substitua bucket-name pelo nome do bucket do Cloud Storage.

   Para especificar URLs de acesso personalizados de Acesso a informações de autoridade (AIA) e Ponto de distribuição de CRL (CDP), use as flags --custom-aia-urls e --custom-cdp-urls. Se especificados, esses URLs serão incluídos em todos os certificados emitidos pela CA e vão substituir os URLs de acesso padrão do bucket do Cloud Storage.

   Para criar uma AC raiz usando uma chave de assinatura gerenciada pelo cliente, execute o seguinte comando:

   gcloud privateca roots create ROOT_CA_ID \
       --location=LOCATION \
       --pool=POOL_ID \
       --kms-key-version=KMS_KEY_VERSION \
       --subject="CN=my-ca, O=Test LLC"
   

   Substitua:

   • ROOT_CA_ID: o identificador exclusivo da CA raiz.
   • LOCATION: o local do pool de ACs.
   • POOL_ID: o nome do pool de ACs.
   • KMS_KEY_VERSION: o ID do recurso completo de uma versão de chave criptográfica do Cloud KMS gerenciada pelo cliente a ser usada como chave de assinatura.

   Para mais detalhes sobre as opções de chave de assinatura e como preparar uma chave de assinatura gerenciada pelo cliente, consulte Configurar chaves de assinatura da CA.

   Para conferir a lista completa de configurações, execute o seguinte comando:

   gcloud privateca roots create --help
   

Terraform

Para criar uma AC raiz usando uma chave de criptografia do Google Cloud , use a seguinte configuração de exemplo:

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

Para criar uma CA raiz usando uma chave autogerenciada, use o seguinte exemplo de configuração:

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,
  ]
}

Go

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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. Crie uma CA raiz.

   Para usar uma chave de assinatura gerenciada pelo cliente, especifique o cloud_kms_key_version no campo key_spec em vez de algorithm.

   Para mais detalhes sobre as opções de chave de assinatura e como preparar uma chave de assinatura gerenciada pelo cliente, consulte Configurar chaves de assinatura da CA.

   Método 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 da solicitação:

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

   Para enviar a solicitação, expanda uma destas opções:

   curl (Linux, macOS ou Cloud Shell)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI do gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

   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/certificateAuthorities?certificate_authority_id=ROOT_CA_ID"

   PowerShell (Windows)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando abaixo:

   $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/certificateAuthorities?certificate_authority_id=ROOT_CA_ID" | Select-Object -Expand Content

   Você receberá uma resposta JSON semelhante a esta:

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

2. Pesquise a operação até que ela seja concluída.

   Método HTTP e URL:

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

   Para enviar a solicitação, expanda uma destas opções:

   curl (Linux, macOS ou Cloud Shell)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI do gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID"

   PowerShell (Windows)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID" | Select-Object -Expand Content

   Você receberá uma resposta JSON semelhante a esta:

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

Observação: por padrão, as CAs raiz são criadas no estado STAGED. Recomendamos que você teste a CA enquanto ela ainda está no estado STAGED. Você precisa solicitar certificados diretamente do estado STAGED da CA porque essas CAs não podem emitir certificados pelo balanceamento de carga do pool de CAs. Para mais informações, consulte Testar uma CA.

Para mais informações sobre os estados da CA, consulte Estados da CA.

Depois de verificar se a AC funciona conforme o esperado, é possível ativá-la para começar a emitir certificados balanceados por carga para o pool de AC.

Observação: se você excluir recursos como pools de CA, autoridades de certificação e modelos de certificado, não será possível criar um novo recurso desse tipo com o mesmo nome no mesmo projeto e local.

Ativar uma CA raiz

gcloud

Para ativar uma CA raiz, execute o seguinte comando gcloud:

gcloud privateca roots enable ROOT_CA_ID --location=LOCATION --pool=POOL_ID

Substitua:

• ROOT_CA_ID: o nome da CA.
• LOCATION: o local do pool de ACs. Para a lista completa de locais, consulte Locais.
• POOL_ID: o nome do pool de ACs.

Terraform

Se você usar o Terraform para criar uma CA raiz, ela será ativada na criação. Para criar uma AC raiz no estado STAGED, defina o campo desired_state como STAGED ao criar a AC.

É possível definir o campo desired_state como ENABLED ou DISABLED após a criação da CA.

Go

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar o serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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. Permita que a CA emita certificados do pool de CAs.

   Método HTTP e URL:

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

   Para enviar a solicitação, expanda uma destas opções:

   curl (Linux, macOS ou Cloud Shell)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI do gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json; charset=utf-8" \
        -d "" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable"

   PowerShell (Windows)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable" | Select-Object -Expand Content

   Você receberá uma resposta JSON semelhante a esta:

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

2. Pesquise a operação até que ela seja concluída.

   Método HTTP e URL:

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

   Para enviar a solicitação, expanda uma destas opções:

   curl (Linux, macOS ou Cloud Shell)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI do gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID"

   PowerShell (Windows)

   Observação: o comando a seguir pressupõe que você tenha feito login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . Para saber qual é a conta ativa no momento, execute o comando gcloud auth list.

   Execute o seguinte comando:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID" | Select-Object -Expand Content

   Você receberá uma resposta JSON semelhante a esta:

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

Atenção: qualquer certificado assinado pela chave privada da CA raiz é amplamente confiável para os navegadores. Recomendamos que você não emita certificados de entidade final de uma CA raiz. Crie CAs subordinadas para emitir certificados de entidade final.

Testar uma CA

Para verificar se uma CA pode emitir certificados, solicite um certificado do pool de CA associado e mencione explicitamente o nome da CA que você quer testar usando a flag --ca.

Use os seguintes métodos para solicitar um certificado de um pool de CA:

1. Peça ao CA Service para criar uma chave privada ou pública para você.
2. Gere sua própria chave privada ou pública e envie uma solicitação de assinatura de certificado (CSR, na sigla em inglês).

É mais fácil usar uma chave privada ou pública gerada automaticamente para solicitar um certificado de uma CA em um pool de CAs. Esta seção fornece informações sobre como testar uma CA usando esse método.

Para usar uma chave privada ou pública gerada automaticamente e solicitar um certificado de uma CA em um pool de CAs, execute o seguinte comando gcloud:

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

Substitua:

• POOL_ID: o nome do pool de ACs.
• ISSUER_LOCATION: o local da autoridade de certificação (CA) que emitiu o certificado digital.
• ROOT_CA_ID: o identificador exclusivo da CA que você quer testar.
• KEY_FILENAME: o arquivo em que a chave gerada é gravada no formato PEM.
• CERT_FILENAME: o arquivo em que o arquivo de cadeia de certificados codificado em PEM resultante é gravado. A ordem da cadeia de certificados é da folha para a raiz.

• DNS_NAME: um ou mais nomes alternativos do assunto (SANs) de DNS separados por vírgulas.

  A flag --generate-key gera uma nova chave privada RSA-2048 na sua máquina.

Para usar uma solicitação de assinatura de certificado (CSR) e pedir um certificado de uma CA em um pool de CA ou para mais informações sobre como solicitar certificados, consulte Solicitar um certificado e ver os certificados emitidos.

Clonar autoridades certificadoras

Para clonar uma CA atual e renová-la ou criar uma nova com a mesma configuração, execute o seguinte comando:

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

Substitua:

• NEW_CA_ID: o identificador exclusivo da nova CA.
• LOCATION: o local do pool de ACs.
• POOL_ID: o nome do pool de ACs em que você quer criar a nova CA.
• EXISTING_CA_ID: o ID da CA de origem ou o identificador totalmente qualificado da CA de origem.

A flag --from-ca é compatível com a criação de CAs raiz e subordinadas. A CA atual precisa estar no mesmo pool que a nova.

A flag --key-algorithm copia toda a configuração da AC da AC atual, exceto a versão da chave do Cloud KMS e o bucket do Cloud Storage. No entanto, ainda é possível substituir qualquer um dos valores de configuração na nova CA fornecendo explicitamente a flag apropriada. Por exemplo, ainda é possível especificar `--subject SUBJECT para usar um novo assunto.

Se você omitir a flag --key-algorithm, o algoritmo vai usar o padrão:

• rsa-pkcs1-4096-sha256 para CAs raiz.
• rsa-pkcs1-2048-sha256 para CAs subordinadas.

Para mais informações sobre esse comando gcloud, consulte gcloud privateca roots create.

A seguir

• Saiba como criar uma CA subordinada.
• Saiba como criar uma AC subordinada de uma AC externa.
• Saiba mais sobre os estados da Califórnia.
• Saiba como solicitar certificados.
• Saiba mais sobre modelos e políticas de emissão.