Wie man Vault zur Verwaltung von Zertifikaten in APISIX verwendet

Junduo Dong

Junduo Dong

June 9, 2023

Technology

API-Gateway ist eine Schlüsselkomponente im API-Lebenszyklusmanagement. Es ist der Eingangspunkt für den gesamten Datenverkehr und dafür verantwortlich, API-Anfragen von nachgelagerten Clients an den richtigen Upstream-Service zur Verarbeitung weiterzuleiten. Daher arbeitet das API-Gateway für die Netzwerkkommunikation zwischen den Upstream-Services und den nachgelagerten Clients.

Als neues Cloud-native-API-Gateway bietet Apache APISIX den TLS/mTLS-Kommunikationsmechanismus zwischen den nachgelagerten Clients und APISIX sowie zwischen APISIX und den Upstream-Services, um die Netzwerksicherheit zwischen ihnen zu gewährleisten. APISIX speichert das SSL-Zertifikat als SSL-Zertifikatsobjekt und realisiert das dynamische Laden des SSL-Zertifikats durch die Erweiterung SNI (Server Name Indication), die das TLS-Protokoll unterstützt.

Um die SSL-Zertifikate sicher in APISIX zu speichern, hat APISIX die Integration mit HashiCorp Vault erreicht, um die einheitliche Verwaltung der SSL-Zertifikate durch die Nutzung der geheimen Sicherheitsspeicherung von Vault zu realisieren. Dieser Artikel nimmt die Konfiguration der HTTPS-Kommunikation zwischen dem nachgelagerten Client und APISIX als Beispiel, um zu erklären, wie APISIX Vault integriert, um die SSL-Zertifikatsverwaltung zu implementieren.

Integrate APISIX with Vault

Was ist ein SSL-Zertifikat?

SSL/TLS ist ein kryptografisches Protokoll, das die Sicherheit der Netzwerkkommunikation schützt, indem es eine verschlüsselte Netzwerkverbindung zwischen den beiden Kommunikationspartnern herstellt. Das SSL/TLS-Protokoll stellt sicher, dass Daten an den richtigen Client und Server gesendet werden, indem es Benutzer und Server authentifiziert. Darüber hinaus kann das SSL/TLS-Protokoll Kommunikationsdaten verschlüsseln und so sicherstellen, dass Daten während der Übertragung nicht gestohlen, manipuliert oder gefälscht werden können.

Ein SSL-Zertifikat ist ein digitales Zertifikat, das die Identität einer Website authentifiziert und eine verschlüsselte Verbindung mit dem SSL/TLS-Protokoll ermöglicht. Ein SSL-Zertifikat wird normalerweise von einer vertrauenswürdigen digitalen Zertifizierungsstelle (CA) ausgestellt und enthält hauptsächlich die folgenden Informationen:

  • Domainname
  • Zertifizierungsstelle
  • Digitale Signatur, die von der Zertifizierungsstelle signiert wurde
  • Zugehörige Subdomains
  • Ausstellungsdatum des Zertifikats
  • Ablaufdatum des Zertifikats
  • Der öffentliche Schlüssel (während der private Schlüssel ein geheimer Schlüssel ist)

Was ist HashiCorp Vault?

HashiCorp Vault (im Folgenden als Vault bezeichnet) ist ein unternehmensweites Geheimnisverwaltungstool, das sensible Daten wie Token, Passwörter und Zertifikate speichern und verwalten kann. Vault kann mit Technologien im gesamten IT-System integriert werden, bietet identitätsbasierte Sicherheitsautomatisierung und Verschlüsselungsdienste, zentralisiert die Kontrolle des Zugriffs auf sensible Daten und Systeme und hilft Organisationen, das Risiko von Datenlecks und Datenexposition zu reduzieren, wodurch die Cloud- und Anwendungssicherheit verbessert wird.

HashiCorp Vault

Wie man APISIX-SSL-Zertifikate in Vault speichert

Umgebungsvorbereitung

Bereitstellen und Konfigurieren des Vault-Services

In diesem Abschnitt werden wir Docker verwenden, um einen Vault-Container-Service bereitzustellen. Sie können diesen Abschnitt überspringen, wenn Sie bereits eine Vault-Service-Instanz in Ihrer Umgebung verfügbar haben.

Erstellen und deployen Sie einen Vault-Container im Dev-Modus, benannt apisix-quickstart-vault. Geben Sie das Vault-Token als apisix-quickstart-vault-token an und mappen Sie Port 8200 auf den Host:

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

Wählen Sie kv als den APISIX-SSL-Zertifikatspeicherpfad:

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

Konfigurieren von APISIX

APISIX muss SSL-Zertifikate aus Vault lesen, daher sollte Vault APISIX Lesezugriff auf den angegebenen Pfad gewähren.

Erstellen Sie eine Vault-Richtlinie namens apisix-policy.hcl, die APISIX Lesezugriff auf den Pfad kv/apisix/ gewährt:

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

Wenden Sie die erstellte Richtliniendatei apisix-policy.hcl auf Vault an:

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

Erstellen Sie ein APISIX-Secret-Objekt mit der ID quickstart-secret-id, um die Vault-Verbindungsinformationen und den Zertifikatspeicherpfad zu speichern:

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"
}'

Speichern von SSL-Zertifikaten in Vault

Erstellen Sie ein selbstsigniertes CA-Zertifikat ca.crt und einen Schlüssel 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

Das SSL-Zertifikat server.crt und der Schlüssel server.key werden von der CA ausgestellt, und sein Common Name (CN) ist 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

Kopieren Sie das ausgestellte SSL-Zertifikat und den Schlüssel in den Vault-Container:

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

Verwenden Sie den Befehl vault kv put, um das SSL-Zertifikat und den Schlüssel als Geheimnis zu speichern, der Schlüssel ist ssl, und der Speicherpfad ist 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

Durch den obigen Befehl haben wir ein Geheimnis namens ssl in Vault gespeichert, das 2 Schlüssel-Wert-Paare enthält: Zertifikat und privater Schlüssel.

Wie man das in Vault gespeicherte APISIX-SSL-Zertifikat verwendet

APISIX unterstützt TLS/mTLS-Netzwerkverschlüsselung zwischen nachgelagerten Clients und APISIX sowie zwischen APISIX und Upstream-Services, wobei die in Vault gespeicherten SSL-Zertifikate verwendet werden können. Wir werden die Konfiguration der HTTPS-Kommunikation zwischen dem Client und APISIX als Beispiel nehmen, um zu demonstrieren, wie das in Vault gespeicherte SSL-Zertifikat in APISIX verwendet wird.

Konfigurieren der HTTPS-Kommunikation zwischen Client und APISIX

Erstellen Sie ein SSL-Zertifikatsobjekt, um das SSL-Zertifikat zu speichern:

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"
}'

Der sni dieses Objekts ist test.com, was mit dem CN, der das Zertifikat ausgestellt hat, übereinstimmt. Die cert und key entsprechen dem ausgestellten Zertifikat und dem privaten Schlüssel, die automatisch aus dem Vault über den eingerichteten Secret-Ressourcen-Locator abgerufen werden, und die Regeln für den Ressourcen-Locator sind:

$secret://$manager/$id/$secret_name/$key
  • manager: Schlüsselverwaltungsdienst Vault
  • id: APISIX-Secret-Ressourcen-ID
  • secret_name: der Geheimnisname in Vault
  • key: der Schlüssel des Schlüssel-Wert-Paares im Geheimnis namens secret_name

Überprüfen der HTTPS-Kommunikation zwischen Client und APISIX

Erstellen Sie eine Route, um alle Anfragen, die an /ip gesendet werden, an den Upstream httpbin.org weiterzuleiten:

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"
  }
}'

Verwenden Sie cURL, um eine Anfrage an https://test.com:9443/ip zu senden, test.com wird auf 127.0.0.1 aufgelöst:

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

Wenn die Konfiguration erfolgreich ist, wird der TLS-Handshake-Prozess zwischen Client und APISIX, der von cURL zurückgegeben wird, den folgenden Ergebnissen entsprechen:

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

Zusammenfassung

Wir haben erklärt, wie APISIX Vault integriert, um die SSL-Zertifikatsverwaltung zu implementieren, und die Konfigurations- und Integrationsschritte detailliert anhand der HTTPS-Kommunikation zwischen nachgelagerten Clients und APISIX gezeigt.

Für verwandte Konzepte und Anwendungsszenarien von SSL-Zertifikaten in APISIX, lesen Sie bitte die folgenden Artikel:

Tags:
Apache APISIX
HashiCorp Vault
Certificate Management