Usar certificados SSL administrados por Google

En esta página, se muestra cómo puedes usar Ingress para crear balanceadores de cargas externos con certificados SSL que administra 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. Para obtener información sobre cómo crear certificados administrados por Google, consulta Certificados administrados por Google.

Versiones de API

Debes configurar certificados SSL administrados por Google mediante un recurso personalizado ManagedCertificate, que está disponible en diferentes versiones de la API, en función de tu versión del clúster de GKE:

La API de ManagedCertificate v1beta2 está disponible en las versiones 1.15 y posteriores del clúster de GKE.
La API de ManagedCertificate v1 está disponible en las versiones de clúster 1.17.9-gke.6300 y posteriores.

Aunque los clústeres de GKE actualmente admiten la API de ManagedCertificate v1beta1, esta versión de la API está obsoleta y se quitará en las próximas versiones de GKE. Se recomienda que uses una versión más nueva de la API.

Migra entre versiones de la API

Los recursos ManagedCertificate se promueven de forma automática a una versión más reciente de la API cuando se actualizan en un clúster que admite la versión más reciente de la API. Los recursos se actualizan de manera periódica, por lo que no necesitas realizar ninguna acción para migrar los recursos.

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.
Agrega una anotación networking.gke.io/managed-certificates al Ingress para asociar el objeto ManagedCertificate. Esta anotación es una lista separada por comas de recursos ManagedCertificate, por ejemplo, cert1,cert2,cert3.

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, mientras que los certificados autoadministrados pueden admitir comodines.

Si necesitas certificados autoadministrados o si ya posees certificados SSL que deseas configurar en el Ingress, consulta la documentación de Ingress.

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

No se admiten las actualizaciones en los certificados administrados por Google.

Para realizar cambios manuales con un tiempo de inactividad mínimo, sigue los pasos que se indican en Actualiza un certificado administrado por Google de forma manual.

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.
Tu "kubernetes.io/ingress.class" debe ser "gce".
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, es posible que esta cambie y requiera que vuelvas a configurar los registros DNS de tu dominio. Usa la herramienta de línea de comandos de gcloud o Cloud Console 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
```
En el comando anterior, address-name es 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 lo siguiente:
```
address: 203.0.113.32
...
```
Console
1. Ve a la página para reservar una dirección estática en Cloud Console.
  Ir a la página Reservar una dirección estática
2. Especifica un nombre para esta dirección IP (por ejemplo, example-ip-address).
3. Especifica si se trata de una dirección IPv4 o IPv6. En el siguiente ejemplo, se usa una dirección IPv4.
4. Selecciona la opción global para el tipo de dirección.
5. Haz clic en Reservar si deseas reservar la IP.
6. 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.

Ver en GitHub
```
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 recurso ManagedCertificate. Este recurso especifica los dominios para los que se creará el certificado SSL. Los dominios de comodín no son compatibles.

Este es un manifiesto de ManagedCertificate de muestra:

Nota: Si ejecutas un clúster en el que la API de ManagedCertificate v1 no está disponible, usa la versión anterior de la API v1beta2.
```
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: certificate-name
spec:
  domains:
    - domain-name1
    - domain-name2
```
Donde:
- certificate-name es el nombre de tu recurso ManagedCertificate.
- domain-name1 y domain-name2 son los nombres de dominio, por ejemplo, example.com, mail.example.com y www.example.com.
Guarda el manifiesto como un archivo llamado certificate-name.yaml y, luego, crea el recurso con el siguiente comando:
```
kubectl apply -f certificate-name.yaml
```
Nota: Para que este recurso ManagedCertificate se convierta en Active, primero debes conectarlo a un recurso Ingress (consulta el paso 3). En otras palabras, no es necesario que ManagedCertificate esté Active para conectarlo a un Ingress.
Crea un Service NodePort para exponer tu aplicación en Internet.

El siguiente es un ejemplo de un archivo de manifiesto de Service:
```
apiVersion: v1
kind: Service
metadata:
  name: service-name
spec:
  selector:
    key: value
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
```
En esta especificación de ejemplo, se seleccionan los pods para incluir en el objeto Service mediante selector. Consulta la documentación de NodePort para obtener detalles sobre cómo configurar Service.

Guarda el manifiesto como un archivo llamado service-name.yaml y, luego, crea el objeto Service con el siguiente comando:
```
kubectl apply -f service-name.yaml
```
Crea un Ingress y vincúlalo al ManagedCertificate que creaste antes.

El siguiente es un manifiesto de Ingress de muestra:
```
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-name
  annotations:
    kubernetes.io/ingress.global-static-ip-name: address-name
    networking.gke.io/managed-certificates: certificate-name
    kubernetes.io/ingress.class: "gce"
spec:
  backend:
    serviceName: service-name
    servicePort: service-port
```
En el ejemplo anterior, se ilustra lo siguiente:
- ingress-name es el nombre del objeto Ingress.
- address-name es el nombre de la dirección IP reservada.
- certificate-name es el nombre del certificado.
- service-name es el nombre del Service que creaste en el paso anterior.
- service-port es el puerto que especificaste en tu manifiesto del Service. Ten en cuenta que este debe ser el valor del campo port, no de targetPort.
Guarda el manifiesto como un archivo llamado ingress-name.yaml y, luego, crea el Ingress con el siguiente comando:
```
kubectl apply -f ingress-name.yaml
```
Nota: El balanceador de cargas puede tomarse entre 10 y 20 minutos para comenzar a funcionar.
Busca la dirección IP del balanceador de cargas creado en el paso anterior. Usa el siguiente comando para obtener la dirección IP del balanceador de cargas:
```
kubectl get ingress
```
El resultado es similar a lo siguiente:
```
NAME              HOSTS     ADDRESS         PORTS     AGE
example-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, puedes consultar la guía sobre cómo administrar 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 se aprovisione el certificado administrado por Google. Este proceso puede tardar hasta 60 minutos. Puedes comprobar el estado del certificado con el siguiente comando:
```
kubectl describe managedcertificate certificate-name
```
Una vez que un certificado se aprovisiona de forma correcta, el valor del campo Status.CertificateStatus será Active. En el siguiente ejemplo, se muestra el resultado de kubectl describe después de que el certificado se aprovisiona con éxito:
```
Name:         certificate-name
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         ManagedCertificate
(...)
Spec:
  Domains:
    domain-name1
    domain-name2
Status:
  CertificateStatus: Active
(...)
```
Para verificar que SSL funcione, visita los dominios con el prefijo https://. Tu navegador indicará que la conexión es segura y podrás 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 sobre cómo configurar 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 certificate-name
```
Cuando el estado sea Activo, actualiza 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 recurso ManagedCertificate y quitar la anotación de Ingress que hace referencia a él.

Borra el recurso ManagedCertificate con kubectl:

kubectl delete -f certificate-name.yaml

Obtendrás el siguiente resultado:

managedcertificate.networking.gke.io "certificate-name" deleted

Quita la anotación del Ingress:
```
kubectl annotate ingress ingress-name 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:
gcloud
Con la herramienta de línea de comandos de gcloud, ejecuta el siguiente comando:
```
gcloud compute addresses delete address-name --global
```
En el ejemplo anterior, address-name es el nombre de la dirección IP.
Console
1. Ve a la página Direcciones IP externas en Cloud Console.
  Ir a la página Direcciones IP externas
2. Marca la casilla que aparece 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.

Ver en GitHub
```
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 sobre cómo resolver problemas con los certificados administrados por Google.

Verifica eventos en recursos de Ingress y ManagedCertificate

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

kubectl describe managedcertificate certificate-name

Donde:

certificate-name es el nombre de tu objeto ManagedCertificate.

Si conectas un ManagedCertificate v1 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

Donde:

ingress-name es el nombre del objeto 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 Ingress), debes crear un solo recurso ManagedCertificate y adjuntarlo a todos los Ingress. Si, en cambio, creas muchos recursos ManagedCertificate y adjuntas cada uno a un Ingress distinto, es posible que la autoridad certificada no pueda verificar la propiedad del dominio y que algunos de tus certificados no se aprovisionen. 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 recursos del Ingress, debes crear un solo recurso ManagedCertificate y adjuntarlo 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 kubernetes.io/pre-shared-cert. Puedes interrumpir esta comunicación en los siguientes casos:

Ejecutas un proceso automatizado que borre la anotación kubernetes.io/pre-shared-cert.
Almacenas una instantánea del Ingress, la borras y restableces el Ingress desde la instantánea. Mientras tanto, es posible que se haya borrado un recurso SslCertificate que aparece en la anotación del certificado ya compartido del Ingress. Ingress tiene una semántica de todo o nada y no funcionará si faltan certificados adjuntos.

Si se interrumpe la comunicación entre Ingress y los certificados administrados por Google, borra el contenido de la anotación kubernetes.io/pre-shared-cert y espera a que el sistema se concilia. Para evitar que se repitan, 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 recurso ManagedCertificate. Si la validación falla, el recurso ManagedCertificate no se crea y se imprime un mensaje de error. A continuación, se explican los diferentes mensajes de error y los motivos:

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

El manifiesto de 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 recurso 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 nuevo certificado administrado por Google para el dominio nuevo.
Conéctalo al Ingress sin quitar el certificado anterior.
Espera hasta que esté Activo.
Desconecta el certificado anterior del Ingress y bórralo.

¿Qué sigue?

Obtén más información sobre los certificados administrados por Google
Obtén más información sobre los balanceadores de cargas HTTP(S) en Google Cloud.
Obtén más información sobre cómo usar varios certificados SSL en el balanceo de cargas HTTP(S) con Ingress.