Crea una autoridad de certificación raíz

En esta página, se describe cómo crear una autoridad de certificación (AC) raíz en un grupo de AC.

Una AC raíz se encuentra en la parte superior de una jerarquía de infraestructura de clave pública (PKI) y es responsable de formar el ancla de confianza de la PKI. Para participar y usar correctamente certificados en una PKI, un dispositivo, software o componente debe confiar en la PKI. Esto se logra configurando el dispositivo, el software o el componente para que confíe en la AC raíz. Como resultado, todos los certificados emitidos por la AC raíz son de confianza.

Antes de comenzar

• Asegúrate de tener los roles de IAM de Administrador de operaciones de CA Service (roles/privateca.caManager) o Administrador del servicio de CA (roles/privateca.admin). Para obtener más información, consulta Configura las políticas de IAM.
• Crea un grupo de CA.
• Determina la configuración de AC.

Crea una AC raíz:

Una AC raíz tiene un certificado autofirmado que debes distribuir a los almacenes de confianza de tus clientes. El certificado de la AC raíz se encuentra en la parte superior de la cadena de certificados. Ninguna otra AC puede revocar el certificado de AC. La CRL de la AC raíz se aplica solo a los demás certificados que emitió la AC raíz, pero no a sí misma.

Console

Para crear una AC raíz, haz lo siguiente.

1. Ve a la página Certificate Authority Service en la consola de Google Cloud.

   Ir a Certificate Authority Service

2. Haz clic en la pestaña Administrador de CA.

   Nota: No puedes crear más de una AC dentro de un grupo de AC con la pestaña Administrador de AC.

3. Haz clic en Crear CA.

Selecciona el tipo de AC

Para establecer la configuración permanente de la AC, como el nivel, la ubicación, el ciclo de vida y el estado operativo en el momento de la creación, haz lo siguiente:

1. Selecciona Root CA.
2. En el campo Válido por, ingresa la duración durante la cual deseas que los certificados emitidos por el certificado de la AC sean válidos.
3. Opcional: Selecciona un nivel para la AC.
4. Haz clic en Región y, en la lista, selecciona la ubicación en la que deseas crear la AC. Te recomendamos que crees la AC geográficamente cerca de los clientes de tu aplicación. Para obtener más información, consulta Cómo elegir la mejor ubicación.

5. Opcional: Selecciona el estado operativo de la AC que se creará.

   

6. Opcional: Haz clic en Perfil de certificado. En la lista, selecciona el perfil de certificado que coincida con el tipo de certificados que deseas que emita la AC.

7. Haz clic en Siguiente.

Configurar nombre del asunto de AC

1. En el campo Organización (O), ingresa el nombre de tu empresa.
2. Opcional: En el campo Unidad organizativa (UO), ingresa la subdivisión de la empresa o la unidad de negocios.
3. Opcional: En el campo Nombre del país, ingresa un código de país de dos letras.
4. Opcional: En el campo Nombre del estado o provincia, ingresa el nombre del estado.
5. Opcional: En el campo Nombre de la localidad, ingresa el nombre de tu ciudad.
6. En el campo Nombre común de la AC (CN), ingresa el nombre de la AC.
7. En el campo ID de grupo, ingresa el nombre del grupo de AC. No puedes cambiar el grupo de AC después de crearla.
8. Haz clic en Siguiente.

Configura el algoritmo y el tamaño de la clave de AC

1. Elige el algoritmo clave que mejor se adapte a tus necesidades. Para obtener información sobre cómo decidir el algoritmo de clave adecuado, consulta Elige un algoritmo de clave.
2. Haz clic en Siguiente.

Configurar artefactos de AC

Los siguientes pasos son opcionales. Si omites estos pasos, se aplicará la configuración predeterminada.

1. Elige si deseas usar un bucket de Cloud Storage administrado por Google o uno autoadministrado.

Si no seleccionas un bucket de Cloud Storage autoadministrado, CA Service crea un bucket administrado por Google en la misma ubicación que la AC.

2. Elige si deseas inhabilitar la publicación de listas de revocación de certificados (CRL) y certificados de la AC en el bucket de Cloud Storage.

La publicación de CRL y de certificado de CA en un bucket de Cloud Storage está habilitada de forma predeterminada. Para inhabilitar estos parámetros de configuración, haz clic en los botones de activación.

3. Haz clic en Siguiente.

Agregar etiquetas

Los siguientes pasos son opcionales.

Si quieres agregar etiquetas a la AC, haz lo siguiente:

1. Haz clic en Agregar elemento.
2. En el campo Clave 1, ingresa la clave de la etiqueta.
3. En el campo Valor 1, ingresa el valor de la etiqueta.
4. Si deseas agregar otra etiqueta, haz clic en Agregar elemento. Luego, agrega la clave y el valor de la etiqueta como se menciona en los pasos 2 y 3.
5. Haz clic en Siguiente.

Revisar la configuración

Revisa cuidadosamente toda la configuración y, luego, haz clic en Crear para crear la AC.

gcloud

1. Para crear un grupo de AC, ejecuta el siguiente comando:

   gcloud privateca pools create POOL_ID
   

   Reemplaza POOL_ID por el nombre del grupo de AC.

   Para obtener más información, consulta Crea un grupo de AC.

   Para obtener más información sobre este comando de gcloud, consulta gcloud privateca pool create.

2. Crea una AC raíz nueva en el grupo de AC que creaste.

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

   Reemplaza lo siguiente:

   • ROOT_CA_ID: Es el nombre de la AC.
   • POOL_ID: Es el nombre del grupo de AC.
   • KEY_ALGORITHM: Es el algoritmo que se usará para crear una clave de Cloud KMS. Esta marca es opcional. Si no incluyes esta marca, el algoritmo de la clave se establece de forma predeterminada en rsa-pkcs1-4096-sha256. Para obtener más información, consulta la marca de --key-algorithm.

   De forma predeterminada, la AC se crea en el estado STAGED. Para habilitar una AC de forma predeterminada, incluye la marca --auto-enable.

   Si deseas usar un bucket de Cloud Storage administrado por el cliente para publicar certificados de la AC y CRL, agrega --bucket bucket-name al comando. Reemplaza bucket-name por el nombre del bucket de Cloud Storage.

   Para ver una lista completa de parámetros de configuración, ejecuta el siguiente comando:

   gcloud privateca roots create --help
   

Terraform

Para crear una AC raíz con una clave administrada por Google, usa la siguiente configuración de ejemplo:

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-hashicorp"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca                  = true
        max_issuer_path_length = 10
      }
      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"
  }
}

Para crear una AC raíz con una clave autoadministrada, usa la siguiente configuración de ejemplo:

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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 de REST

1. Crea una CA raíz.

   HTTP method and URL:

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

   Cuerpo JSON de la solicitud:

   {
   "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 tu solicitud, expande una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

   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)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

   $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

   Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

2. Sondea la operación hasta que se complete.

   HTTP method and URL:

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

   Para enviar tu solicitud, expande una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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

   Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

Nota: Las AC raíz se crean en el estado STAGED de forma predeterminada. Te recomendamos que pruebes tu AC mientras aún está en el estado STAGED. Debes solicitar certificados directamente del estado STAGED de la AC porque estas AC no pueden emitir certificados a través del balanceo de cargas de grupos de AC. Para obtener más información, consulta Cómo probar una AC.

Para obtener más información sobre los estados de AC, consulta Estados de AC.

Después de verificar que la AC funciona como se espera, puedes habilitarla para comenzar a emitir certificados con balanceo de cargas para el grupo de AC.

Nota: Si borras recursos como grupos de AC, autoridades certificadoras y plantillas de certificado, no podrás crear un recurso nuevo de ese tipo con el mismo nombre en el mismo proyecto y la misma ubicación.

Habilita una AC raíz

gcloud

Para habilitar una AC raíz, ejecuta el siguiente comando gcloud:

gcloud privateca roots enable ROOT_CA_ID --pool=POOL_ID

Reemplaza lo siguiente:

• ROOT_CA_ID: Es el nombre de la AC.
• POOL_ID: Es el nombre del grupo de AC.

Terraform

Si usas Terraform para crear una AC raíz, esta se habilitará cuando se cree. Para crear una AC raíz en el estado STAGED, establece el campo desired_state en STAGED cuando crees la AC.

Puedes establecer el campo desired_state en ENABLED o DISABLED después de la creación de la AC.

Go

Para autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en CA Service, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 de REST

1. Permite que la AC emita certificados desde el grupo de AC.

   HTTP method and URL:

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

   Para enviar tu solicitud, expande una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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

   Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

2. Sondea la operación hasta que se complete.

   HTTP method and URL:

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

   Para enviar tu solicitud, expande una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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)

   Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

   Ejecuta el siguiente 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

   Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

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

Precaución: Los navegadores confían en cualquier certificado firmado por la clave privada de la AC raíz. Te recomendamos que no emitas certificados de entidad final desde una AC raíz. Crea AC subordinadas para emitir certificados de entidad final.

Prueba una AC

Para verificar que una AC pueda emitir certificados, solicita uno del grupo de AC asociado y menciona de forma explícita el nombre de la AC que quieres probar con la marca --ca.

Puedes usar los siguientes métodos para solicitar un certificado de un grupo de AC:

1. Haz que CA Service cree una clave privada o pública por ti.
2. Genera tu propia clave privada o pública y envía una solicitud de firma de certificado (CSR).

Es más fácil usar una clave privada generada automáticamente o una clave pública para solicitar un certificado de una AC en un grupo de AC. En esta sección, se proporciona información para probar una AC con ese método.

Si quieres usar una clave privada o una clave pública generada automáticamente para solicitar un certificado de una AC en un grupo de AC, ejecuta el siguiente comando de 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

Reemplaza lo siguiente:

• POOL_ID: Es el nombre del grupo de AC.
• ROOT_CA_ID: Es el identificador único de la AC que deseas probar.
• KEY_FILENAME: El archivo en el que se escribe la clave generada en formato PEM.
• CERT_FILENAME: Es el archivo en el que se escribe el archivo de cadena de certificados con codificación PEM resultante. El orden de la cadena de certificados es de la hoja a la raíz.

• DNS_NAME: Uno o más nombres de asunto de DNS (SAN) separados por comas.

  La marca --generate-key genera una clave privada RSA-2048 nueva en tu máquina.

Si deseas usar una solicitud de firma de certificado (CSR) para solicitar un certificado de una AC en un grupo de AC o si deseas obtener más información sobre la solicitud de certificados, consulta Cómo solicitar un certificado y ver los certificados emitidos.

Clonar autoridades certificadoras

Ejecuta el siguiente comando para clonar una AC existente con el fin de renovarla, o bien crear una nueva con la misma configuración:

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

Reemplaza lo siguiente:

• NEW_CA_ID: Es el identificador único de la AC nueva.
• POOL_ID: Es el nombre del grupo de AC en el que deseas crear la AC nueva.

La marca --from-ca es compatible con la creación de AC subordinadas y raíz. La AC existente debe estar en el mismo grupo de AC que la nueva.

La marca --key-algorithm copia toda la configuración de la AC existente (excepto la versión de clave de Cloud KMS y el bucket de Cloud Storage). Sin embargo, puedes anular cualquiera de los valores de configuración en la AC nueva si proporcionas explícitamente la marca adecuada. Por ejemplo, aún puedes especificar SUBJECT "--subject" para usar un sujeto nuevo.

Si omites la marca --key-algorithm, el algoritmo usará lo siguiente de forma predeterminada:

• rsa-pkcs1-4096-sha256 para las AC raíz.
• rsa-pkcs1-2048-sha256 para AC subordinadas.

Para obtener más información sobre este comando gcloud, consulta gcloud privateca roots create.

¿Qué sigue?

• Obtén más información sobre cómo crear una AC subordinada.
• Obtén más información sobre cómo solicitar certificados.
• Obtén más información sobre las plantillas y políticas de emisión.