Activer SSL pour Cloud Endpoints avec ESPv2

OpenAPI | gRPC

Cette page explique comment activer un port SSL (Secure Sockets Layer) lors du déploiement d'Extensible Service Proxy V2 (ESPv2) avec Google Kubernetes Engine, Kubernetes ou Compute Engine. Vous pouvez activer un port SSL pour votre service Endpoints déployé dans certains cas d'utilisation.

Avant de commencer, assurez-vous d'avoir déjà consulté les tutoriels sur le type de service et l'environnement que vous avez choisis, et de savoir comment déployer ESPv2 sans SSL.

Configurer vos clés et certificats SSL

Pour configurer votre port SSL afin qu'il diffuse les requêtes HTTPS, procédez comme suit :

Assurez-vous que votre fichier de clé SSL est nommé server.key et que votre fichier de certificat s'appelle server.crt. Pour les tests, vous pouvez générer des fichiers autosignés server.key et server.crt à l'aide d'OpenSSL à l'aide de la commande suivante :
```
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout ./server.key -out ./server.crt
```
Indiquez à la fois CN et subjectAltName dans votre certificat de serveur. La valeur de ces attributs doit correspondre au DNS ou à l'adresse IP utilisés par les clients pour appeler votre service. Sinon, le handshake SSL échouera.

Activer SSL pour ESPv2 sur Kubernetes

Pour activer le port SSL pour ESPv2 sur Kubernetes, procédez comme suit :

Créez un secret Kubernetes contenant la clé et le certificat SSL :

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

Modifiez les fichiers de configuration Kubernetes, par exemple echo-ssl.yaml, comme illustré dans l'extrait suivant :

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

Remarque : L'exemple de configuration affiche les lignes à modifier. Le fichier de configuration complet est nécessaire au déploiement du fichier sur Cloud Endpoints.

Installez les codes secrets Kubernetes créés en tant que volumes, à l'aide des instructions de la page relative aux Volumes Kubernetes.
Démarrez ESPv2, comme décrit dans la section Spécifier des options de démarrage pour ESPv2. N'oubliez pas d'ajouter l'option de démarrage --ssl_server_cert_path pour spécifier le chemin d'accès aux fichiers de certificat installés.
Démarrez le service avec le fichier de configuration Kubernetes mis à jour à l'aide de kubectl.
```
kubectl apply -f echo-ssl.yaml
```
Remarque : Si vous disposez déjà d'un déploiement Kubernetes, vous pouvez le mettre à jour directement.
Générez le certificat racine du client à l'aide de la commande OpenSSL suivante :
```
   openssl x509 -in ./server.crt -out ./client.pem -outform PEM
 
```
Si le client utilise curl, le fichier client.pem peut être spécifié avec l'option --caroot. Pour gRPC, client.pem est utilisé comme fichier de certificat racine de l'identifiant SSL pour le canal gRPC.

Mettre à jour les certificats SSL

Il est important de mettre régulièrement à jour vos certificats SSL. Pour mettre à jour vos certificats SSL, procédez comme suit :

Créez des certificats, comme décrit à l'étape 1 ci-dessus.
Installez les nouveaux certificats sur les secrets Kubernetes, comme décrit à l'étape 3 ci-dessus.
Mettez à jour le déploiement Kubernetes ESPv2, comme décrit à l'étape 5 ci-dessus.
Générez un nouveau fichier de certificat racine du client, comme décrit à l'étape 6 ci-dessus.

Activer SSL pour ESPv2 sur Compute Engine

Pour activer SSL sur Compute Engine, commencez par copier les fichiers server.key et server.crt dans le dossier /etc/nginx/ssl de l'instance Compute Engine, comme suit :

Exécutez la commande suivante et remplacez INSTANCE_NAME par le nom de l'instance Compute Engine :
```
gcloud compute scp server.* INSTANCE-NAME
```
Connectez-vous à l'instance via ssh.
```
gcloud compute ssh INSTANCE-NAME
```
Dans la zone d'instance de VM, créez le répertoire et copiez-y les fichiers :
```
  sudo mkdir -p /etc/esp/ssl
  sudo cp server.* /etc/esp/ssl/
```
Suivez les instructions applicables à votre type de service pour effectuer un déploiement avec Docker. Lorsque vous exécutez le conteneur Docker d'ESPv2, utilisez la commande suivante :
```
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
```
Par rapport à la commande non SSL docker run, la version SSL de la commande crée une configuration différente. Par exemple, la commande SSL :
- installe le dossier contenant les fichiers de clé et CRT dans le conteneur à l'aide de --volume ;
- fait appel à --ssl_server_cert_path=/etc/esp/ssl pour indiquer à ESPv2 de chercher les fichiers de certificat du serveur server.key et server.crt dans le dossier /etc/esp/ssl ;
- modifie l'option de mappage de port --publish. Les requêtes entrantes vers le port HTTPS 443 sont mappées sur le port 9000 d'ESPv2.
  
  Remarque : Le conteneur ESPv2 ne peut pas être lié à des ports privilégiés, y compris le port 443. Servez-vous plutôt de l'indicateur --publish pour mapper le port 443 avec un --listener_port non privilégié, tel que 9000.

Mettre à jour les certificats SSL

Il est important de mettre régulièrement à jour vos certificats SSL. Pour mettre à jour vos certificats SSL, procédez comme suit:

Créez des certificats et copiez-les dans des instances de VM, comme décrit à l'étape 1 ci-dessus.
Copiez les nouveaux certificats dans le répertoire /etc/esp/ssl, comme décrit à l'étape 3 ci-dessus.
Arrêtez et redémarrez le conteneur ESPv2 à l'aide de la commande sudo docker run, comme décrit à l'étape 4 ci-dessus.

Tester le port SSL

Pour faciliter le test du port SSL, définissez les variables d'environnement suivantes :

Définissez IP_ADDRESS sur l'adresse IP de l'instance Compute Engine avec le nouveau certificat SSL.

Remarque : Les exemples de commandes de test ci-dessous supposent que le serveur ne possède pas encore de nom de domaine complet (FQDN) et que IP_ADDRESS a été utilisé comme nom de domaine complet lors de la génération du certificat autosigné. Lorsque le serveur obtient un nom de domaine complet, utilisez-le pour générer le certificat. Remplacez ensuite IP_ADDRESS par le nom de domaine complet dans les commandes ci-dessous.
Définissez ENDPOINTS_KEY sur une clé API valide.

Une fois le port SSL activé, vous pouvez utiliser HTTPS pour envoyer des requêtes à Extensible Service Proxy. Si votre certificat est autosigné, utilisez -k pour activer l'option non sécurisée dans la commande curl :

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

Vous pouvez également générer le certificat au format pem et vous servir de l'option --cacert pour utiliser le certificat autosigné dans le fichier curl, comme indiqué ci-dessous :

  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