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

Habilita SSL para Cloud Endpoints con el ESPv2

OpenAPI | gRPC

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 V2 (ESPv2) 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.

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 ESPv2 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:

Verifica que el archivo de claves de SSL se llame server.key y que el archivo de certificados se llame server.crt. Para realizar la prueba, puedes generar server.key y server.crt autofirmados mediante OpenSSL a través del siguiente comando:
```
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout ./server.key -out ./server.crt
```
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.

Habilita SSL para ESPv2 en Kubernetes

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

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

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

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: 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.

Activa los secretos de Kubernetes que creaste como volúmenes y sigue las instrucciones de la página de volúmenes de Kubernetes.
Inicia el ESPv2 como se describe en Especifica opciones de inicio para el ESPv2, pero asegúrate de agregar la marca de inicio --ssl_server_cert_path con el fin de especificar la ruta para los archivos de certificados activados.
Inicia el servicio con el archivo de configuración de Kubernetes actualizado mediante kubectl.
```
kubectl apply -f echo-ssl.yaml
```
Nota: Si ya tienes una implementación de Kubernetes, puedes actualizar la implementación de forma directa.
Genera el certificado raíz para el cliente mediante el siguiente comando de OpenSSL:
```
   openssl x509 -in ./server.crt -out ./client.pem -outform PEM
 
```
Si el cliente usa curl, se puede usar el archivo client.pem en la marca --caroot. Para gRPC, se usa client.pem como certificado raíz. de la credencial SSL para el canal de gRPC.

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 ESPv2 de Kubernetes, como se describe en el paso 5.
Vuelve a generar el archivo de certificado raíz del cliente, como se describe en el paso 6.

Habilita SSL para el ESPv2 en Compute Engine

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

Ejecuta el siguiente comando y reemplaza INSTANCE_NAME por el nombre de tu instancia de Compute Engine:
```
gcloud compute scp server.* INSTANCE-NAME
```
Conéctate a la instancia mediante ssh.
```
gcloud compute ssh INSTANCE-NAME
```
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/
```
Sigue las instrucciones según el tipo de servicio que implementarás con Docker. Cuando ejecutes el contenedor de Docker del 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 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_server_cert_path=/etc/esp/ssl para indicarle al ESPv2 que busque los archivos de certificados del 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 en HTTPS se asignan al puerto 9000 del ESPv2.
  
  Nota: El contenedor de ESPv2 no puede vincularse con puertos privilegiados, incluido el puerto 443. En su lugar, usa la marca --publish para asignar el puerto 443 a un --listener_port sin privilegios, como el 9000.

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 ESPv2 con el comando sudo docker run, como se describe en el paso 4.

Prueba el puerto SSL

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

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

Nota: En los siguientes comandos de prueba, se supone que el servidor aún no tiene un nombre de dominio completamente calificado (FQDN) y que se usó IP_ADDRESS como el FQDN cuando se generó el certificado autofirmado. Cuando el servidor obtenga un FQDN, úsalo para generar el certificado. Luego, reemplaza IP_ADDRESS por el FQDN en los comandos de ejemplo que se muestran a continuación.
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 es autofirmado, puedes usar -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 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