Habilitar SSL para Cloud Endpoints con ESPv2

En esta página se explica cómo habilitar un puerto de capa de sockets seguros (SSL) al desplegar Extensible Service Proxy V2 (ESPv2) con Google Kubernetes Engine, Kubernetes o Compute Engine. En algunos casos prácticos, puede que quieras habilitar un puerto SSL para el servicio Endpoints implementado.

Antes de empezar, asegúrate de haber consultado los tutoriales del tipo de servicio y el entorno que hayas elegido, y de saber cómo implementar ESPv2 sin SSL.

Configurar las claves y los certificados SSL

Para configurar el puerto SSL para que responda a solicitudes HTTPS, sigue estos pasos:

  1. Comprueba que el archivo de clave SSL se llama server.key y el archivo de certificado, server.crt. Para hacer pruebas, puedes generar un server.key y un server.crt autofirmados con OpenSSL mediante el siguiente comando:

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout ./server.key -out ./server.crt

  2. Especifica tanto CN como subjectAltName en tu certificado de servidor. El valor de estos atributos debe coincidir con el DNS o la IP que usan los clientes para llamar a tu servicio. De lo contrario, se producirá un error en el handshake SSL.

Habilitar SSL para ESPv2 en Kubernetes

Para habilitar el puerto SSL de ESPv2 en Kubernetes, sigue estos pasos:

  1. Crea un secreto de Kubernetes con tu clave y certificado SSL:

    kubectl create secret generic esp-ssl \
  --from-file=./server.crt --from-file=./server.key

  2. Edita los archivos de configuración de Kubernetes, por ejemplo, echo-ssl.yaml, como se muestra en el siguiente fragmento:

    template:
  metadata:
    labels:
      app: esp-echo
  spec:
    volumes:
    - name: esp-ssl
      secret:
        secretName: esp-ssl
    containers:
    - name: esp
      image: gcr.io/endpoints-release/endpoints-runtime:2
      args: [
        "--listener_port", "9000",
        "--backend", "127.0.0.1:8081",
        "--service", "SERVICE_NAME",
        "--rollout_strategy", "managed",
        "--ssl_server_cert_path", "/etc/esp/ssl",
      ]
      ports:
        - containerPort: 9000
      volumeMounts:
      - mountPath: /etc/esp/ssl
        name: esp-ssl
        readOnly: true
    - name: echo
      image: gcr.io/endpoints-release/echo:latest
      ports:
        - containerPort: 8081

    Nota: En el ejemplo de configuración se muestran las líneas que se deben editar. Para desplegar el archivo en Cloud Endpoints, se necesita el archivo de configuración completo.

  3. Monta los secretos de Kubernetes que has creado como volúmenes siguiendo las instrucciones de la página de volúmenes de Kubernetes.

  4. Inicia ESPv2 como se describe en Especificar opciones de inicio para ESPv2, pero asegúrate de añadir la marca de inicio --ssl_server_cert_path para especificar la ruta de los archivos de certificado montados.

  5. Inicia el servicio con el archivo de configuración de Kubernetes actualizado mediante kubectl.

    kubectl apply -f echo-ssl.yaml

  6. Genera el certificado raíz del cliente con el siguiente comando de OpenSSL:

       openssl x509 -in ./server.crt -out ./client.pem -outform PEM

    Si el cliente usa curl, el archivo client.pem se puede usar en la marca --caroot. En el caso de gRPC, client.pem se usa como archivo de certificado raíz de la credencial SSL del canal gRPC.

Actualizar certificados SSL

Es importante que actualices tus certificados SSL periódicamente. Para actualizar tus certificados SSL, debes seguir estos pasos:

  • Crea nuevos certificados, tal como se describe en el paso 1 de este artículo.
  • Monta los nuevos certificados en los secretos de Kubernetes, tal como se describe en el paso 3 anterior.
  • Actualiza la implementación de Kubernetes de ESPv2, tal como se describe en el paso 5 anterior.
  • Vuelve a generar el archivo del certificado raíz del cliente, tal como se describe en el paso 6 de este artículo.

Habilitar SSL para ESPv2 en Compute Engine

Para habilitar SSL en Compute Engine, primero copia los archivos server.key y server.crt en la carpeta /etc/nginx/ssl de tu instancia de Compute Engine. Para ello, sigue estos pasos:

  1. Ejecuta el siguiente comando y sustituye INSTANCE_NAME por el nombre de tu instancia de Compute Engine:

    gcloud compute scp server.* INSTANCE-NAME

  2. Conéctate a la instancia mediante ssh.

    gcloud compute ssh INSTANCE-NAME

  3. En el cuadro de la VM de la instancia, crea el directorio y copia los archivos:

      sudo mkdir -p /etc/esp/ssl
  sudo cp server.* /etc/esp/ssl/

  4. Sigue las instrucciones correspondientes a tu tipo de servicio para implementar con Docker. Cuando ejecutes el contenedor Docker de ESPv2, usa este comando:

    sudo docker run --name=esp \
 --detach \
 --publish=443:9000 \
 --net=esp_net \
 --volume=/etc/esp/ssl:/etc/esp/ssl \
  gcr.io/endpoints-release/endpoints-runtime:2 \
 --service=SERVICE_NAME \
 --rollout_strategy=managed \
 --backend=echo:8080 \
 --ssl_server_cert_path=/etc/esp/ssl \
 --listener_port=9000

    En comparación con el comando docker run no compatible con SSL, la versión compatible con SSL del comando crea una configuración diferente. Por ejemplo, el comando SSL:

    • Monta la carpeta con los archivos de clave y CRT en el contenedor mediante --volume.
    • Usa --ssl_server_cert_path=/etc/esp/ssl para indicar a ESPv2 que busque los archivos de certificado de servidor server.key y server.crt en la carpeta /etc/esp/ssl.

    • Cambia la marca de asignación de puertos --publish. Las solicitudes entrantes al puerto 443 de HTTPS se asignan al puerto 9000 de ESPv2.

Actualizar certificados SSL

Es importante que actualices tus certificados SSL periódicamente. Para actualizar tus certificados SSL, debes seguir estos pasos:

  • Crea certificados y cópialos en las instancias de VM, tal como se describe en el paso 1 de este artículo.
  • Copia los nuevos certificados en el directorio /etc/esp/ssl, tal como se describe en el paso 3 anterior.
  • Detén y reinicia el contenedor ESPv2 con el comando sudo docker run, tal como se describe en el paso 4 anterior.

Probar el puerto SSL

Para facilitar la prueba del puerto SSL, define las siguientes variables de entorno:

  1. Define IP_ADDRESS como la dirección IP de la instancia de Compute Engine con el nuevo certificado SSL.

  2. Asigna a ENDPOINTS_KEY una clave de API válida.

Una vez que se haya habilitado el puerto SSL, podrá usar HTTPS para enviar solicitudes al proxy de servicio extensible. Si tu certificado tiene firma automática, usa -k para activar la opción no segura en curl:

curl -k -d '{"message":"hello world"}' -H "content-type:application/json" \
https://IP_ADDRESS:443/echo?key=ENDPOINTS_KEY

También puedes generar el certificado en formato pem y usar la opción --cacert para usar el certificado autofirmado en curl, como se muestra a continuación:

  openssl x509 -in server.crt -out client.pem -outform PEM
  curl --cacert "./client.pem" -d '{"message":"hello world"}' -H "content-type:application/json" \
  https://IP_ADDRESS:443/echo?key=ENDPOINTS_KEY