Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Habilita SSL para Cloud Endpoints con el ESP

En esta página, se explica cómo habilitar un puerto de capa de conexión segura (SSL) cuando se implementa el proxy de servicio extensible (ESP) con Google Kubernetes Engine, Kubernetes o Compute Engine. Se recomienda habilitar un puerto SSL para tu servicio de Endpoints implementado en algunos casos de uso. Por ejemplo, si usas la función de transcodificación de gRPC, se recomienda que tu servicio reciba solicitudes de HTTP 1.1 y de gRPC en el mismo puerto.

Antes de comenzar, asegúrate de haber revisado los instructivos para el tipo de servicio y el entorno que elegiste y de saber cómo implementar el ESP sin SSL.

Configura tus claves y certificados SSL

A fin de configurar tu puerto SSL para que entregue solicitudes HTTPS, sigue los pasos que se muestran a continuación:

  1. Verifica que el archivo de claves de SSL se llame nginx.key y que el archivo de certificados se llame nginx.crt. Para realizar la prueba, puedes generar nginx.key y nginx.cert autofirmados mediante OpenSSL a través del siguiente comando:

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout ./nginx.key -out ./nginx.crt
  2. Especifica CN y subjectAltName en el certificado del 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, fallará el protocolo de enlace de SSL.

Habilitar SSL para el ESP en Kubernetes

Si quieres habilitar el puerto SSL para ESP en Kubernetes, haz lo siguiente:

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

    kubectl create secret generic nginx-ssl \
    --from-file=./nginx.crt --from-file=./nginx.key
  2. Edita los archivos de configuración de Kubernetes, por ejemplo, esp_echo_gke.yaml, como se muestra en el fragmento siguiente:

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

    Nota: El ejemplo de configuración muestra las líneas que se deben editar. Para implementar el archivo en Cloud Endpoints se necesita el archivo de configuración completo.

  3. Activa los secretos de Kubernetes que creaste como volúmenes y sigue las instrucciones de la página de volúmenes de Kubernetes.

  4. Inicia el ESP como se describe en Opciones de especificación de inicio del ESP, pero asegúrate de agregar la marca de inicio --ssl_port a fin de habilitar el puerto SSL. (Ten en cuenta que el puerto SSL predeterminado es 443)

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

    kubectl apply -f esp_echo_gke.yaml

Actualiza los certificados SSL

Es importante actualizar los certificados SSL periódicamente. Para actualizar tus certificados SSL, debes seguir los siguientes pasos:

  • Crea certificados nuevos, como se describe más arriba en el Paso 1.
  • Activa los certificados nuevos en los secretos de Kubernetes, como se describe en el paso 3 de arriba.
  • Actualiza la implementación del ESP de Kubernetes, como se describe en el paso 5.

Habilita SSL para el ESP en Compute Engine

Para habilitar SSL en Compute Engine, primero debes copiar los archivos nginx.key y nginx.crt en la carpeta /etc/nginx/ssl de tu instancia de Compute Engine mediante los siguientes pasos:

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

    gcloud compute scp nginx.* INSTANCE-NAME
    
  2. Conéctate a la instancia mediante ssh.

    gcloud compute ssh INSTANCE-NAME
  3. En el cuadro de 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 según el tipo de servicio que implementarás con Docker. Cuando ejecutes el contenedor de Docker del ESP, usa este comando:

    sudo docker run --name=esp \
     --detach \
     --publish=443:443 \
     --net=esp_net \
     --volume=/etc/nginx/ssl:/etc/nginx/ssl \
     --link=echo:echo \
     gcr.io/endpoints-release/endpoints-runtime:1 \
     --service=SERVICE_NAME \
     --rollout_strategy=managed \
     --backend=echo:8080 \
     --ssl_port=443

    En comparación con el comando docker run sin SSL, la versión de SSL del comando crea una configuración diferente. Por ejemplo, el comando de SSL realiza lo siguiente:

    • Activa la carpeta con la clave y los archivos CRT en el contenedor con --volume.
    • Usa --ssl_port=443 para indicarle al ESP que habilite SSL en el puerto 443.
    • Cambia la marca de asignación de puertos --publish.

Actualiza los certificados SSL

Es importante actualizar los certificados SSL periódicamente. Para actualizar tus certificados SSL, debes seguir los siguientes pasos:

  • Crea certificados nuevos y cópialos en instancias de VM, como se describe en el paso 1 de arriba.
  • Copia los certificados nuevos en el directorio /etc/esp/ssl, como se describe en el paso 3 de arriba.
  • Detén y reinicia el contenedor del ESP con el comando sudo docker run, como se describe en el paso 4.

Prueba el puerto SSL

Para facilitar la prueba, configura las variables de entorno siguientes:

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

  2. Configura ENDPOINTS_KEY como una clave de API válida.

Una vez habilitado el puerto SSL, puedes usar HTTPS para enviar solicitudes al proxy de servicio extensible. Si tu certificado está autofirmado, 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

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

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

Habilita SSL con certificados SSL administrados por Google

La compatibilidad de GKE con los certificados SSL administrados por Google se encuentra en fase Beta. Sigue las instrucciones de la sección sobre cómo usar los certificados SSL administrados por Google para configurar SSL.

Si no quieres depender de servicios Beta, puedes integrar tu ESP en la implementación de GKE directamente con una autoridad certificada.

Puedes usar:

Para obtener más información, consulta el instructivo Let's Encrypt en GKE en GitHub.