Usar certificados SSL administrados por Google

Autopilot Estándar

En esta página, se muestra cómo puedes usar objetos Ingress para crear balanceadores de cargas externos con certificados SSL administrados por Google. Estos certificados son certificados de Validación de dominio (DV) que Google aprovisiona, renueva y administra para tus nombres de dominio. Estos certificados no demuestran tu identidad ni la de tu organización.

Si deseas obtener información para crear certificados administrados por Google con Google Cloud, consulta Certificados administrados por Google.

Los certificados SSL administrados por Google de GKE admiten clústeres públicos y privados.

Crea un Ingress con un certificado administrado por Google

Para configurar un certificado SSL administrado por Google y asociarlo con un Ingress, debes seguir estos pasos:

Crea un objeto ManagedCertificate en el mismo espacio de nombres que el Ingress.
Agrega la anotación networking.gke.io/managed-certificates al Ingress para asociar el objeto ManagedCertificate a un Ingress. Esta anotación es una lista separada por comas de objetos ManagedCertificate.

Limitaciones

Los certificados administrados por Google son menos flexibles que los certificados que tú obtienes y administras. Los certificados administrados por Google admiten hasta 100 dominios sin comodines. A diferencia de los certificados autoadministrados, los certificados administrados por Google no admiten dominios comodines.

Si necesitas certificados autoadministrados o si ya posees certificados SSL que deseas configurar en el Ingress, consulta la sección sobre cómo configurar HTTPS (TLS) entre el cliente y el balanceador de cargas.

La cantidad y el tipo de certificados admitidos por un Ingress están definidos por los límites de los certificados SSL administrados por Google.

No se admiten las actualizaciones en los certificados administrados por Google. Para obtener más información, consulta Actualiza un certificado administrado por Google de forma manual.

Si el certificado se revoca directamente con la autoridad certificadora, Google no lo rotará de forma automática. Debes borrar el ManagedCertificate y crear uno nuevo.

Requisitos previos

Debes ser dueño del nombre de dominio. El nombre de dominio no debe tener más de 63 caracteres. Puedes usar Google Domains o algún otro registrador.
Si usas un clúster de GKE Standard, el complemento HttpLoadBalancing debe estar habilitado.
El ingressClassName debe ser "gce".
Debes aplicar los recursos Ingress y ManagedCertificate en el mismo proyecto y el mismo espacio de nombres.
Crea una dirección IP externa (estática) reservada. Reservar una dirección IP estática garantiza que te pertenece, incluso si borras el Ingress. Si no reservas una dirección IP, es posible que esta cambie y requiera que vuelvas a configurar los registros DNS de tu dominio. Usa Google Cloud CLI o la consola de Google Cloud para crear una dirección IP reservada.
gcloud
Para crear una dirección IP reservada, ejecuta el siguiente comando:
```
gcloud compute addresses create ADDRESS_NAME --global
```
Reemplaza ADDRESS_NAME por el nombre de la dirección IP reservada que creas.

Para encontrar la dirección IP estática que creaste, ejecuta el siguiente comando:
```
gcloud compute addresses describe ADDRESS_NAME --global
```
El resultado es similar a este:
```
address: 203.0.113.32
...
```
Console
Para crear una dirección IP reservada, sigue estos pasos:
1. Ve a la página Direcciones IP externas en la consola de Google Cloud.
  
  Ir a Direcciones IP externas
2. Especifica un nombre para la dirección IP (por ejemplo, example-ip-address).
3. Especifica si deseas una dirección IPv4 o IPv6.
4. Selecciona la opción Global para Tipo.
5. Haga clic en Reservar. La dirección IP aparece en la columna Dirección externa.
Config Connector
Nota: En este paso, se necesita Config Connector. Sigue las instrucciones de instalación para instalar Config Connector en el clúster.
```
apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: example-ip-address
spec:
  location: global
```
Para implementar este manifiesto, descárgalo en tu máquina como compute-address.yaml y ejecuta lo siguiente:
```
kubectl apply -f compute-address.yaml
```

Configura un certificado administrado por Google

Crea un objeto ManagedCertificate. Este recurso especifica los dominios para el certificado SSL. Los dominios de comodín no son compatibles.

El siguiente manifiesto describe un objeto ManagedCertificate. Guarda el manifiesto como managed-cert.yaml.
```
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: managed-cert
spec:
  domains:
    - FQDN_1
    - FQDN_2
```
Reemplaza lo siguiente:
- FQDN_1, FQDN_2: Son los nombres de dominio completamente calificados que te pertenecen. Por ejemplo, example.com y www.example.com.
Aplica el manifiesto al clúster:
```
kubectl apply -f managed-cert.yaml
```

Crea un Service de tipo NodePort para exponer tu aplicación a Internet.

En el siguiente manifiesto, se describe un Service de tipo NodePort. Guarda el manifiesto como mc-service.yaml.

apiVersion: v1
kind: Service
metadata:
  name: mc-service
spec:
  selector:
    app: mc-service
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Aplica el manifiesto al clúster:
```
kubectl apply -f mc-service.yaml
```
Nota: Para que este objeto ManagedCertificate se convierta en Active, debes adjuntarlo a un Ingress. No es necesario que ManagedCertificate sea Active para que puedas conectarlo a un Ingress.

Crea un Ingress.

En el siguiente manifiesto, se describe un Ingress que usa el ManagedCertificate que creaste. Guarda el manifiesto como managed-cert-ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: managed-cert-ingress
  annotations:
    kubernetes.io/ingress.global-static-ip-name: ADDRESS_NAME
    networking.gke.io/managed-certificates: managed-cert
    ingressClassName: "gce"
spec:
  defaultBackend:
    service:
      name: mc-service
      port:
        number: SERVICE_PORT

Reemplaza lo siguiente:

ADDRESS_NAME: nombre de la dirección IP reservada.
SERVICE_PORT: valor de ports.port en tu manifiesto de servicio.

Aplica el manifiesto al clúster:
```
kubectl apply -f managed-cert-ingress.yaml
```
Nota: Puede llevar varias horas que Google Cloud aprovisione el balanceador de cargas y el certificado administrado, y que el balanceador de cargas comience a usar el certificado nuevo. Para obtener más información, consulta Implementa un certificado administrado por Google con autorización de balanceador de cargas.
Obtén la dirección IP del balanceador de cargas.
```
kubectl get ingress
```
El resultado es similar a este:
```
NAME                 HOSTS       ADDRESS         PORTS     AGE
managed-cert-ingress   *         203.0.113.32     80       54s
```
La dirección IP del balanceador de cargas aparece en la columna ADDRESS. Si usas una dirección IP estática reservada, esa será la dirección del balanceador de cargas.

Si la dirección no aparece en la lista, espera a que Ingress termine de configurarse.
Configura los registros DNS de tus dominios para que apunten a la dirección IP del balanceador de cargas. Si usas Cloud DNS, consulta Administra registros para obtener más información.
Nota: Debes esperar a que se propaguen los registros DNS que configuraste para poder continuar.
Espera a que el certificado administrado por Google termine de aprovisionar. Este proceso puede llevar hasta 60 minutos. Puedes verificar el estado del certificado con el siguiente comando:
```
kubectl describe managedcertificate managed-cert
```
El resultado es similar a este:
```
Name:         managed-cert
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         ManagedCertificate
(...)
Spec:
 Domains:
   FQDN_1
   FQDN_2
Status:
 CertificateStatus: Active
(...)
```
El valor del campo Status.CertificateStatus indica que se aprovisionó el certificado. Si Status.CertificateStatus no es Active, el certificado aún no se aprovisionó.
Puedes verificar los eventos en un recurso Ingress con el siguiente comando:
```
kubectl describe ingress INGRESS_NAME
```
Reemplaza INGRESS_NAME por el nombre de tu Ingress.
Para verificar que SSL funcione, visita los dominios con el prefijo https://. Tu navegador indica que la conexión es segura y puedes ver los detalles del certificado.

Migra a certificados administrados por Google desde certificados autoadministrados

Cuando migras un Ingress desde el uso de certificados SSL autoadministrados a certificados SSL administrados por Google, no debes borrar ningún certificado SSL autoadministrado antes de que los certificados SSL administrados por Google se activen. Una vez que los certificados SSL administrados por Google se aprovisionan de forma correcta, estos se activan de forma automática. Cuando los certificados SSL administrados por Google están activos, puedes borrar tus certificados SSL autoadministrados.

Usa estas instrucciones para migrar desde los certificados autoadministrados hasta los SSL administrados por Google.

Agrega un nuevo certificado administrado por Google al Ingress, como se describe en la sección Configura un certificado administrado por Google.
Espera hasta que el estado del recurso del certificado administrado por Google sea Activo. Verifica el estado del certificado con el siguiente comando:
```
kubectl describe managedcertificate managed-cert
```
Cuando el estado sea Active, actualiza el Ingress para quitar las referencias al certificado autoadministrado.

Quita un certificado administrado por Google

Para quitar un certificado administrado por Google de tu clúster, debes borrar el objeto ManagedCertificate y quitar la anotación de Ingress que hace referencia a él.

Borra el objeto ManagedCertificate:

kubectl delete -f managed-cert.yaml

El resultado es similar a este:

managedcertificate.networking.gke.io "managed-cert" deleted

Quita la anotación del Ingress:

kubectl annotate ingress managed-cert-ingress networking.gke.io/managed-certificates-

Observa el signo menos, -, al final del comando.

Libera la dirección IP estática que reservaste para tu balanceador de cargas.

Puedes usar Google Cloud CLI, la consola de Google Cloud o Config Connector para liberar una dirección IP reservada.
gcloud
Usa el siguiente comando para liberar la dirección IP reservada:
```
gcloud compute addresses delete ADDRESS_NAME --global
```
Reemplaza ADDRESS_NAME por el nombre de la dirección IP.
Console
Para liberar la dirección IP reservada, sigue estos pasos:
1. Ve a la página Direcciones IP externas en la consola de Google Cloud.
  
  Ir a Direcciones IP externas
2. Selecciona la casilla de verificación junto a la dirección IP que deseas liberar.
3. Haz clic en Liberar dirección IP.
Config Connector
Nota: En este paso, se necesita Config Connector. Sigue las instrucciones de instalación para instalar Config Connector en el clúster.
```
apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: example-ip-address
spec:
  location: global
```
Para implementar este manifiesto, descárgalo en tu máquina como compute-address.yaml y ejecuta lo siguiente:
```
kubectl delete -f compute-address.yaml
```

Soluciona problemas

En esta sección, se proporciona información para resolver problemas con los certificados administrados por Google.

Verifica eventos en `ManagedCertificate` y recursos de Ingress

Si excedes la cantidad de certificados permitidos, se agrega un evento con un motivo TooManyCertificates a ManagedCertificate. Puedes verificar los eventos en un objeto ManagedCertificate con el siguiente comando:

kubectl describe managedcertificate CERTIFICATE_NAME

Reemplaza CERTIFICATE_NAME por el nombre del ManagedCertificate.

Si conectas un ManagedCertificate no existente a un Ingress, se agrega un evento con un motivo MissingCertificate al Ingress. Puedes verificar los eventos en un recurso Ingress con el siguiente comando:

kubectl describe ingress INGRESS_NAME

Reemplaza INGRESS_NAME por el nombre de tu Ingress.

El certificado administrado no se aprovisiona cuando el dominio se resuelve en direcciones IP de varios balanceadores de cargas

Cuando tu dominio se resuelve en direcciones IP de varios balanceadores de cargas (varios objetos Ingress), debes crear un solo objeto ManagedCertificate y adjuntarlo a todos los objetos Ingress. Si, en cambio, creas muchos objetos ManagedCertificate y adjuntas cada uno a un Ingress distinto, es posible que la autoridad certificadora no pueda verificar la propiedad del dominio y algunos de tus certificados no lo hagan. Para que la verificación sea exitosa, el certificado debe estar visible en todas las direcciones IP a las que se resuelve el dominio.

De manera específica, cuando el dominio se resuelve en una dirección IPv4 y otra IPv6 configuradas con diferentes objetos del Ingress, debes crear un solo objeto de ManagedCertificate y conectarlo a ambos Ingress.

Comunicación interrumpida entre los certificados administrados por Google e Ingress

Los certificados administrados se comunican con el Ingress mediante la anotación ingress.gcp.kubernetes.io/pre-shared-cert. Puedes interrumpir esta comunicación, por ejemplo, si realizas estas acciones:

Ejecutas un proceso automatizado que borre la anotación ingress.gcp.kubernetes.io/pre-shared-cert.
Almacenas una instantánea del Ingress y, luego, borras y restableces el Ingress a partir de la instantánea. Mientras tanto, es posible que se haya borrado un recurso SslCertificate enumerado en la anotación ingress.gcp.kubernetes.io/pre-shared-cert. Ingress no funciona si falta alguno de sus certificados adjuntos.

Si se interrumpe la comunicación entre los certificados administrados por Google e Ingress, borra el contenido de la anotación ingress.gcp.kubernetes.io/pre-shared-cert y espera a que el sistema se concilie. Para evitar la recurrencia, asegúrate de que la anotación no se modifique ni se borre de forma involuntaria.

Errores de validación cuando se crea un certificado administrado por Google

Las definiciones de ManagedCertificate se validan antes de crear el objeto ManagedCertificate. Si la validación falla, el objeto ManagedCertificate no se crea y se imprime un mensaje de error. Los diferentes mensajes de error y los motivos se explican de la siguiente manera:

`spec.domains in body should have at most 100 items`

El manifiesto ManagedCertificate enumera más de 100 dominios en el campo spec.domains. Los certificados administrados por Google solo admiten hasta 100 dominios.

`spec.domains in body should match '^(([a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9][a-zA-Z0-9])\.)+[a-zA-Z][-a-zA-Z0-9][a-zA-Z0-9]\.?$'`

Especificaste un nombre de dominio no válido o un nombre de dominio comodín en el campo spec.domains. El objeto ManagedCertificate no admite dominios comodines (por ejemplo, *.example.com).

`spec.domains in body should be at most 63 chars long`

Especificaste un nombre de dominio que es demasiado largo. Los certificados administrados por Google admiten nombres de dominio con un máximo de 63 caracteres.

Actualiza de manera manual un certificado administrado por Google

Para actualizar el certificado de forma manual a fin de que el certificado del dominio anterior continúe funcionando hasta que se aprovisione el certificado del dominio nuevo, sigue estos pasos:

Crea un ManagedCertificate para el dominio nuevo.
Agrega el nombre de ManagedCertificate a la anotación networking.gke.io/managed-certificates en el Ingress mediante una lista separada por comas. No quites el nombre del certificado anterior.
Espera hasta que ManagedCertificate se active.
Desconecta el certificado anterior del Ingress y bórralo.

Cuando creas un ManagedCertificate, Google Cloud crea un certificado SSL administrado por Google. No puedes actualizar este certificado. Si actualizas el ManagedCertificate, Google Cloud borra y vuelve a crear el certificado SSL administrado por Google.

Para proporcionar Ingress encriptado con HTTPS seguro para tus clústeres de GKE, consulta el ejemplo Ingress seguro.

¿Qué sigue?

Obtén más información sobre los certificados administrados por Google.
Obtén información sobre cómo configurar un balanceador de cargas de aplicaciones externo con Ingress.
Obtén más información para usar varios certificados SSL con balanceadores de cargas de aplicaciones externos con Ingress.
Implementa un Ingress seguro.