Usar certificados SSL administrados por Google

Autopilot estándar

En esta página, se muestra cómo puedes usar certificados SSL administrados por Google para proteger Ingress en GKE. Aprenderás a usar el servicio automatizado de administración de certificados de Google para simplificar la encriptación HTTPS de tus aplicaciones.

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.

Esta página está dirigida a especialistas en redes y seguridad que planifican e implementan la seguridad de red, y que desarrollan y mantienen políticas de seguridad. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido deGoogle Cloud , consulta Roles de usuario y tareas comunes de GKE.

Antes de leer esta página, asegúrate de tener conocimientos prácticos de GKE y una buena comprensión de las herramientas de redes y la seguridad de la red.

Para obtener información sobre cómo crear certificados administrados por Google con Google Cloud, consulta Certificados administrados por Google.

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 Configura 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 cualquier registrador de nombres de dominio para obtener un nombre de dominio.

Nota: Google Domains ya no está en funcionamiento. Ahora Squarespace administra los dominios que se compraron anteriormente en Google Domains. Puedes administrar tu dominio y sus registros DNS desde tu cuenta de Squarespace.
Si usas un clúster de GKE Standard, el complemento HttpLoadBalancing debe estar habilitado.
Tu manifiesto de Ingress debe incluir la anotación kubernetes.io/ingress.class: "gce". No se admite el campo ingressClassName.
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. Haz 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
    kubernetes.io/ingress.class: "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: Es posible que Google Cloud tarde varias horas en aprovisionar el balanceador de cargas y el certificado administrado, y en 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
```

¿Qué sigue?

Obtén más información sobre los certificados administrados por Google.
Obtén más 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.