Esta página foi traduzida pela API Cloud Translation.

Criar uma autoridade certificadora subordinada

Esta página descreve como criar autoridades certificadoras (ACs) subordinadas em um pool de ACs.

As ACs subordinados são responsáveis por emitir certificados diretamente para entidades finais, como usuários, computadores e dispositivos. As ACs subordinadas são assinadas criptograficamente por uma AC mãe, que geralmente é a AC raiz. Por isso, os sistemas que confiam CA raiz, confia automaticamente nas CAs subordinadas e nos certificados de entidade final que as ACs subordinadas emitem.

Antes de começar

Verifique se você tem o papel do IAM de Gerente de operações de serviço de CA (roles/privateca.caManager) ou de administrador do serviço de CA (roles/privateca.admin). Para mais informações, consulte Configurar políticas do IAM.
Criar um pool de CA.
Selecione a raiz da CA.

Criar uma AC subordinada

As ACs subordinadas são mais fáceis de revogar e rotacionar do que as ACs raiz. Se você tiver vários cenários de emissão de certificados, é possível criar uma CA subordinada para cada um desses cenários. Adicionar várias ACs subordinadas a um pool de ACs ajuda você a conseguir um melhor balanceamento de carga das solicitações de certificado e um QPS total efetivo maior.

Para criar uma AC subordinada, faça o seguinte:

Console

Acesse a página Certificate Authority Service no console do Google Cloud.

Acesse Certificate Authority Service
Clique na guia Gerente de CAs.
Clique em Criar CA.

Selecionar o tipo de CA

Clique em AC subordinada.
Clique em A raiz da AC está no Google Cloud.
No campo Válido por, insira o período de validade do certificado de AC.
Opcional: escolha o nível da CA. O nível padrão é Enterprise. Para mais informações, consulte Selecionar os níveis de operação.
Clique em Região para selecionar um local para o AC. Saiba mais em Locais.
Opcional: em Initialized state (Estado inicializado), selecione o estado em que a AC precisa estar. estar no momento da criação.
Opcional: em Configurar um cenário de emissão, clique em Perfil do certificado e selecione o perfil do certificado que que atenda melhor às suas necessidades na lista. Para mais informações, consulte Perfis de certificado.
Clique em Próxima.

Configurar o nome do assunto da CA

No campo Organização (O), digite o nome da sua empresa.
Opcional: no campo Unidade organizacional (UO), insira a subdivisão da empresa ou a unidade de negócios.
Opcional: no campo Nome do país, insira um código de país com duas letras.
Opcional: no campo Nome do estado ou da província, insira o nome do seu estado.
Opcional: no campo Nome da localidade, digite o nome da sua cidade.
No campo Nome comum da CA (CN), digite o nome da CA.
No campo ID do pool, insira o nome do pool de ACs. Não é possível mudar o pool de ACs depois de criar a AC.
Clique em Próxima.

. Configurar o algoritmo e o tamanho da chave da AC

Escolha o algoritmo de chave que melhor atende às suas necessidades. Para informações sobre como decidir o algoritmo de chave adequado, consulte Escolher um algoritmo de chave.
Clique em Próxima.

. Configurar artefatos de AC

As etapas a seguir são opcionais. Se você pular essas etapas, as configurações padrão serão aplicadas.

Escolha entre usar uma conta gerenciada pelo Google do bucket do Cloud Storage.

Se você não selecionar um bucket autogerenciado do Cloud Storage, O CA Service cria um bucket gerenciado pelo Google no mesmo local como a CA.

Escolha se você quer desativar a publicação de certificados listas de revogação (CRLs) e certificados de AC para o Cloud Storage do Google Cloud.

Publicação da CRL e do certificado de CA em um bucket do Cloud Storage é ativado por padrão. Para desativar essas configurações, clique nos botões de alternância.

Clique em Próxima.

. Adicionar rótulos

As etapas a seguir são opcionais.

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

Clique em Adicionar item.
No campo Chave 1, digite a chave do rótulo.
No campo Valor 1, digite o valor do marcador.
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.
Clique em Próxima.

. Revise as configurações

Revise cuidadosamente todas as configurações e clique em Criar para criar a CA.

gcloud

Crie um pool de ACs para a AC subordinada:
```
gcloud privateca pools create SUBORDINATE_POOL_ID
```
Substitua SUBORDINATE_POOL_ID pelo nome do pool de ACs.

Para mais informações sobre a criação de pools de ACs, consulte Criar um pool de ACs.

Para mais informações sobre o comando gcloud privateca pools create, consulte gcloud privateca pools create.
Crie uma AC subordinada no pool de ACs criado.

Observação: é possível acessar o ID de recurso do emissor (POOL_ID) copiando o ID do comando "create" ou usando o comando gcloud privateca pools list.
```
gcloud privateca subordinates create SUBORDINATE_CA_ID \
  --pool=SUBORDINATE_POOL_ID \
  --issuer-pool=POOL_ID \
  --key-algorithm="ec-p256-sha256" \
  --subject="CN=Example Server TLS CA, O=Example LLC"
```
A declaração a seguir é retornada quando a AC subordinada é criada.
```
Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
```
Para conferir uma lista completa de configurações, execute o seguinte comando gcloud:
```
gcloud privateca subordinates create --help
```
O comando retorna exemplos para criar uma AC subordinada cujo emissor está localizado no serviço de AC ou em outro lugar.

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  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 = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_certificate_authority" "default" {
  // 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-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 = "HashiCorp"
        common_name  = "my-subordinate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs
        max_issuer_path_length = 0
      }
      key_usage {
        base_key_usage {
          digital_signature  = true
          content_commitment = true
          key_encipherment   = false
          data_encipherment  = true
          key_agreement      = true
          cert_sign          = true
          crl_sign           = true
          decipher_only      = true
        }
        extended_key_usage {
          server_auth      = true
          client_auth      = false
          email_protection = true
          code_signing     = true
          time_stamping    = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  type = "SUBORDINATE"
}

Java

Para autenticar no 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.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

Para autenticar no 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_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}")

Ativar uma AC subordinada

Para ativar uma AC subordinada, faça o seguinte:

Console

Acesse a página Certificate Authority Service em no console do Google Cloud.

Acesse Certificate Authority Service
Clique na guia Gerenciador de ACs.
Em Autoridades certificadoras, selecione a AC que você quer ativar.
Clique em Ativar.
Na caixa de diálogo exibida, clique em Fazer o download da CSR para fazer o download do Arquivo CSR codificado em PEM que a AC emissora pode assinar.
Clique em Próxima.
No campo Fazer upload da cadeia de certificados, clique em Procurar.
Faça upload do arquivo do certificado assinado com a extensão .crt.
Clique em Activate.

gcloud

Para ativar uma AC subordinada recém-criada, execute o seguinte comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

Substitua:

SUBORDINATE_CA_ID: o identificador exclusivo da AC subordinada.
SUBORDINATE_POOL_ID: o nome do pool de ACs que contém a AC subordinada.

Para mais informações sobre o comando gcloud privateca subordinates enable, consulte gcloud privateca subordinates enable.

Terraform

Defina o campo desired_state como ENABLED na AC subordinada e execute terraform apply.

A seguir

Saiba como solicitar certificados.
Saiba mais sobre modelos e políticas de emissão.