Comment utiliser Vault pour gérer les certificats dans APISIX

La passerelle API est un composant de base essentiel dans la gestion du cycle de vie des API. Elle constitue l'entrée de tout le trafic et est responsable du routage des requêtes API des clients en aval vers le service en amont approprié pour traitement. Par conséquent, la passerelle API fonctionne pour la communication réseau entre les services en amont et les clients en aval.

En tant que nouvelle passerelle API cloud-native, Apache APISIX fournit le mécanisme de communication TLS/mTLS entre les clients en aval et APISIX, ainsi qu'entre APISIX et les services en amont, afin de garantir la sécurité du réseau entre eux. APISIX enregistre le certificat SSL en tant qu'objet de certificat SSL et réalise le chargement dynamique du certificat SSL via l'extension SNI (Server Name Indication) qui prend en charge le protocole TLS.

Pour stocker de manière sécurisée les certificats SSL dans APISIX, APISIX a réalisé l'intégration avec HashiCorp Vault, permettant ainsi une gestion unifiée des certificats SSL en tirant parti du stockage sécurisé des secrets de Vault. Cet article prend comme exemple la configuration de la communication HTTPS entre le client en aval et APISIX pour expliquer comment APISIX intègre Vault pour implémenter la gestion des certificats SSL.

Qu'est-ce qu'un certificat SSL ?

SSL/TLS est un protocole cryptographique qui protège la sécurité de la communication réseau en établissant une connexion réseau chiffrée entre les deux parties communicantes. Le protocole SSL/TLS garantit que les données sont envoyées au bon client et serveur en authentifiant les utilisateurs et les serveurs. De plus, le protocole SSL/TLS peut chiffrer les données de communication, assurant ainsi que les données ne peuvent pas être volées, modifiées ou falsifiées pendant la transmission.

Un certificat SSL est un certificat numérique qui authentifie l'identité d'un site web et permet une connexion chiffrée en utilisant le protocole SSL/TLS. Un certificat SSL est généralement émis par une autorité de certification numérique de confiance (CA), qui inclut principalement les informations suivantes :

• Nom de domaine
• Autorité de certification
• Signature numérique signée par l'autorité de certification
• Sous-domaines associés
• Date d'émission du certificat
• Date d'expiration du certificat
• La clé publique (tandis que la clé privée est une clé secrète)

Qu'est-ce que HashiCorp Vault ?

HashiCorp Vault (ci-après appelé Vault) est un outil de gestion des secrets de niveau entreprise qui peut stocker et gérer des données sensibles telles que des jetons, des mots de passe et des certificats. Vault peut être intégré avec les technologies de l'ensemble du système informatique, fournir des services de sécurité automatisée basée sur l'identité et de chiffrement, contrôler de manière centralisée l'accès aux données et systèmes sensibles, et aider les organisations à réduire le risque de fuite et d'exposition des données, améliorant ainsi la sécurité du cloud et des applications.

Comment stocker les certificats SSL d'APISIX dans Vault

Préparation de l'environnement

• Installer Docker
• Installer cURL
• Un service APISIX en cours d'exécution, ou suivre le tutoriel de démarrage pour déployer un conteneur Docker APISIX

Déployer et configurer le service Vault

Dans cette section, nous utiliserons Docker pour déployer un service de conteneur Vault. Vous pouvez sauter cette section si vous avez déjà une instance de service Vault disponible dans votre environnement.

Créer et déployer un conteneur Vault en mode Dev, nommé apisix-quickstart-vault. Spécifier le Vault Token comme apisix-quickstart-vault-token et mapper le port 8200 à l'hôte :

docker run -d --cap-add=IPC_LOCK \
  -e 'VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200' \
  -e 'VAULT_ADDR=http://0.0.0.0:8200' \
  -e 'VAULT_DEV_ROOT_TOKEN_ID=apisix-quickstart-vault-token' \
  -e 'VAULT_TOKEN=apisix-quickstart-vault-token' \
  --network=apisix-quickstart-net \
  --name apisix-quickstart-vault \
  -p 8200:8200 vault:1.13.0

Sélectionner kv comme chemin de stockage des certificats SSL d'APISIX :

docker exec apisix-quickstart-vault vault secrets enable -path=kv -version=1 kv

Configurer APISIX

APISIX doit lire les certificats SSL depuis Vault, donc Vault doit accorder à APISIX l'autorisation de lecture sur le chemin spécifié.

Créer une politique Vault nommée apisix-policy.hcl, accordant à APISIX l'accès en lecture au chemin kv/apisix/ :

docker exec apisix-quickstart-vault /bin/sh -c "echo '
path \"kv/apisix/*\" {
    capabilities = [\"read\"]
}
' > /etc/apisix-policy.hcl"

Appliquer le fichier de politique créé apisix-policy.hcl à Vault :

docker exec apisix-quickstart-vault vault policy write apisix-policy /etc/apisix-policy.hcl

Créer un objet secret APISIX avec l'id quickstart-secret-id pour enregistrer les informations de connexion à Vault et le chemin de stockage des certificats :

curl -i "http://127.0.0.1:9180/apisix/admin/secrets/vault/quickstart-secret-id" -X PUT -d '
{
    "uri": "http://apisix-quickstart-vault:8200",
    "prefix": "kv/apisix",
    "token" : "apisix-quickstart-vault-token"
}'

Stocker les certificats SSL dans Vault

Créer un certificat CA auto-signé ca.crt et une clé ca.key :

openssl genrsa -out ca.key 2048 && \
  openssl req -new -sha256 -key ca.key -out ca.csr -subj "/CN=ROOTCA" && \
  openssl x509 -req -days 36500 -sha256 -extensions v3_ca -signkey ca.key -in ca.csr -out ca.crt

Le certificat SSL server.crt et la clé server.key sont émis par la CA, et son nom commun (CN) est test.com :

openssl genrsa -out server.key 2048 && \
  openssl req -new -sha256 -key server.key -out server.csr -subj "/CN=test.com" && \
  openssl x509 -req -days 36500 -sha256 -extensions v3_req \
  -CA ca.crt -CAkey ca.key -CAserial ca.srl -CAcreateserial \
  -in server.csr -out server.crt

Copier le certificat SSL et la clé émis dans le conteneur Vault :

docker cp server.key apisix-quickstart-vault:/root/
docker cp server.crt apisix-quickstart-vault:/root/

Utiliser la commande vault kv put pour stocker le certificat SSL et la clé en tant que secret, la clé est ssl, et le chemin de stockage est kv/apisix :

docker exec apisix-quickstart-vault vault kv put kv/apisix/ssl test.com.crt=@/root/server.crt test.com.key=@/root/server.key

Grâce à la commande ci-dessus, nous avons stocké un secret nommé ssl dans Vault, qui contient 2 paires clé-valeur : le certificat et la clé privée.

Comment utiliser le certificat SSL d'APISIX stocké dans Vault

APISIX prend en charge le chiffrement réseau TLS/mTLS entre les clients en aval et APISIX, et entre APISIX et les services en amont, où les certificats SSL stockés dans Vault peuvent être utilisés. Nous prendrons comme exemple la configuration de la communication HTTPS entre le client et APISIX pour démontrer comment utiliser le certificat SSL stocké dans Vault dans APISIX.

Configurer la communication HTTPS entre le client et APISIX

Créer un objet de certificat SSL pour contenir le certificat SSL :

curl -i "http://127.0.0.1:9180/apisix/admin/ssls" -X PUT -d '
{
  "id": "quickstart-tls-client-ssl",
  "sni": "test.com",
  "cert": "$secret://vault/quickstart-secret-id/ssl/test.com.crt",
  "key": "$secret://vault/quickstart-secret-id/ssl/test.com.key"
}'

Le sni de cet objet est test.com, ce qui correspond au CN qui a émis le certificat. Le cert et la key correspondent au certificat et à la clé privée émis, qui sont automatiquement obtenus depuis Vault via le localisateur de ressource secret établi, et les règles du localisateur de ressource sont :

$secret://$manager/$id/$secret_name/$key

• manager : service de gestion des clés Vault
• id : ID de ressource secret APISIX
• secret_name : le nom du secret dans Vault
• key : la clé de la paire clé-valeur dans le secret nommé secret_name

Vérifier la communication HTTPS entre le client et APISIX

Créer une route pour rediriger toutes les requêtes envoyées à /ip vers le service en amont httpbin.org :

curl -i "http://127.0.0.1:9180/apisix/admin/routes" -X PUT -d '
{
  "id": "quickstart-client-ip",
  "uri": "/ip",
  "upstream": {
    "nodes": {
      "httpbin.org:80":1
    },
    "type": "roundrobin"
  }
}'

Utiliser cURL pour envoyer une requête à https://test.com:9443/ip, test.com résout à 127.0.0.1 :

curl -ikv --resolve "test.com:9443:127.0.0.1" "https://test.com:9443/ip"

Si la configuration est réussie, le processus de poignée de main TLS entre le client et APISIX retourné par cURL sera le même que les résultats suivants :

* Added test.com:9443:127.0.0.1 to DNS cache
* Hostname test.com was found in DNS cache
*   Trying 127.0.0.1:9443...
* Connected to test.com (127.0.0.1) port 9443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
*  CAfile: /etc/ssl/certs/ca-certificates.crt
*  CApath: /etc/ssl/certs
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server accepted to use h2
* Server certificate:
*  subject: CN=test.com
*  start date: Apr 21 07:47:54 2023 GMT
*  expire date: Mar 28 07:47:54 2123 GMT
*  issuer: CN=ROOTCA
*  SSL certificate verify result: unable to get local issuer certificate (20), continuing anyway.
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
* Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
* Using Stream ID: 1 (easy handle 0x556274d632e0)
> GET /ip HTTP/2
> Host: test.com:9443
> user-agent: curl/7.74.0
> accept: */*
>
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* old SSL session ID is stale, removing
* Connection state changed (MAX_CONCURRENT_STREAMS == 128)!
< HTTP/2 200
HTTP/2 200
...

Résumé

Nous avons expliqué comment APISIX intègre Vault pour implémenter la gestion des certificats SSL, et montré les étapes de configuration et d'intégration en détail en prenant comme exemple la communication HTTPS entre les clients en aval et APISIX.

Pour les concepts et scénarios d'utilisation des certificats SSL dans APISIX, veuillez vous référer aux articles suivants :

• Certificats SSL
• Configurer HTTPS en amont
• Configurer HTTPS entre le client et APISIX
• Configurer mTLS entre le client et APISIX