Wie man API Gateway und Consul integriert?

Fei Han

February 25, 2022

Ecosystem

Hintergrundinformationen

Consul ist eine Service-Mesh-Lösung. Einer seiner Kernbestandteile, Consul KV, ist eine verteilte Key-Value-Datenbank, deren Hauptzweck darin besteht, Konfigurationsparameter und Metadaten zu speichern, während sie es Benutzern auch ermöglicht, indizierte Objekte zu speichern.

Im Microservice-Architekturmodell kann die manuelle Konfiguration der Upstream-Dienste bei Änderungen wie Kapazitätserweiterungen oder Hardwareausfällen zu einem starken Anstieg der Wartungskosten führen. Um dies zu lösen, bietet Apache APISIX ein Service-Discovery-Register an, um dynamisch die neuesten Dienstinstanzinformationen zu erhalten und so die Wartungskosten für Benutzer zu reduzieren.

Derzeit unterstützt Apache APISIX das auf Consul KV basierende Service-Discovery-Register mit dem von der Community beigetragenen consul_kv-Modul.

Funktionsweise

Apache APISIX nutzt das consul_kv-Modul der Consul KV-Distributed-Key-Value-Speicherfunktion, um den Anbieter und den Verbraucher eines Dienstes zu entkoppeln und die beiden Kernfunktionen eines Service-Discovery-Registers zu implementieren.

  1. Dienstregistrierung: Dienstleister registrieren ihre Dienste im Register.
  2. Dienstermittlung: Dienstverbraucher finden die Routing-Informationen der Dienstleister über das Register.

Auf dieser Grundlage wird Apache APISIX flexibler und besser an bestehende Microservice-Architekturen angepasst, um die Anforderungen der Benutzer besser zu erfüllen.

Consul-Architekturen

Aktivierung von Consul in Apache APISIX

Die Testumgebungen in diesem Artikel werden in Docker mit docker-compose erstellt.

  1. Apache APISIX herunterladen.

    # Repository von apisix-docker klonen
git clone https://github.com/apache/apisix-docker.git

  2. Consul-Ordner und Konfigurationsdateien erstellen.

    # Consul-Ordner erstellen
mkdir -p ~/docker-things/consul/ && cd $_
# Konfigurationsdateien erstellen
touch docker-compose.yml server1.json

  3. Die docker-compose.yml-Datei bearbeiten.

    version: '3.8'

services:
consul-server1:
image: consul:1.9.3
container_name: consul-server1
restart: always
volumes:
  - ./server1.json:/consul/config/server1.json:ro
networks:
  - apisix
ports:
  - '8500:8500'
command: 'agent -bootstrap-expect=1'

networks:
apisix:
external: true
name: example_apisix

  4. Die server1.json-Datei bearbeiten.

    {
node_name: consul-server1,
server: true,
addresses: {
http: 0.0.0.0
}
}

  5. Consul-bezogene Konfigurationsinformationen zur Apache APISIX-Konfigurationsdatei apisix_conf/config.yaml hinzufügen.

    # config.yml
# ...andere Konfigurationen
discovery:
consul_kv:
servers:
  - http://consul-server1:8500
prefix: upstreams

  6. Apache APISIX und Consul starten.

    # Zum Beispiel- und Consul-Ordner wechseln, APISIX und Consul starten
docker-compose up -d

  7. Den Testdienst bei Consul registrieren. Das Beispiel enthält zwei Webdienste, die direkt für Tests verwendet werden können.

    # docker-compose.yml des Beispiels überprüfen
# Es sind zwei Webdienste sichtbar
$ cat docker-compose.yml | grep web
# Ausgabe
web1:
- ./upstream/web1.conf:/etc/nginx/nginx.conf
web2:
- ./upstream/web2.conf:/etc/nginx/nginx.conf

  8. Die IP-Adressen dieser Webdienste bestätigen.

    $ sudo docker inspect -f='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(sudo docker ps -aq) | grep web
# Ausgabe
/example-web1-1 - 172.26.0.7
/example-web2-1 - 172.26.0.2

  9. Eine Anfrage an die HTTP-API von Consul senden, um den Testdienst zu registrieren.

    # Mit der entsprechenden IP registrieren
curl \
-X PUT \
-d ' {weight: 1, max_fails: 2, fail_timeout: 1}' \
http://127.0.0.1:8500/v1/kv/upstreams/webpages/172.26.0.7:80

curl \
-X PUT \
-d ' {weight: 1, max_fails: 2, fail_timeout: 1}' \
http://127.0.0.1:8500/v1/kv/upstreams/webpages/172.26.0.2:80

    Der Pfad nach /v1/kv/ folgt dem Format {Prefix}/{Service Name}/{IP}:{Port}.

    {Prefix} ist das Präfix, das bei der Konfiguration von Consul in APISIX angegeben wurde, während {Service Name} und {IP}:{Port} vom Benutzer entsprechend dem Upstream-Dienst festgelegt werden müssen.

    Das Datenformat lautet {"weight": , "max_fails": , "fail_timeout": }.

  10. Überprüfen, ob der Testdienst erfolgreich registriert wurde.

    curl http://127.0.0.1:8500/v1/kv/upstreams/webpages?keys

    Die folgende Rückmeldung zeigt eine erfolgreiche Registrierung an.

    [upstreams/webpages/172.26.0.2:80,upstreams/webpages/172.26.0.7:80]%

Route erstellen und Consul aktivieren

Consul wird über die von Apache APISIX bereitgestellte Admin-API zur Route hinzugefügt.

X-API-KEY und upstream.service_name müssen vor dem Hinzufügen festgelegt werden.

  • X-API-KEY: Der Zugriffstoken für die Admin-API, in diesem Beispiel verwenden wir den Standardwert edd1c9f034335f136f87ad84b625c8f1.
  • upstream.service_name: Der Name des Upstream-Dienstes, der den Dienst in einem Register angibt, der an eine Route gebunden wird, sollte auf die URL gesetzt werden, die bei der Registrierung des Testdienstes mit Consul verwendet wurde, wobei der {IP}:{Port}-Teil am Ende entfernt wird. Wir können auch die Memory-Dump-API von Apache APISIX verwenden, um die URL des Dienstes zu erhalten und zu bestätigen, ob der Upstream-Dienst korrekt ermittelt wurde.
$ curl http://127.0.0.1:9092/v1/discovery/consul_kv/dump | jq
# Ausgabe
{
  "services": {
    # Dieser Schlüssel ist die erforderliche URL
    "http://consul-server1:8500/v1/kv/upstreams/webpages/": [
      {
        "port": 80,
        "host": "172.26.0.7",
        "weight": 1
      },
      {
        "port": 80,
        "host": "172.26.0.2",
        "weight": 1
      }
    ]
  },
  "config": {
    # ...Konfigurationen
  }
}

Route hinzufügen

Hier wird die Anfrage mit der URL /consul/* an http://consul-server1:8500/v1/kv/upstreams/webpages/ weitergeleitet. Außerdem muss discovery_type auf consul_kv gesetzt werden, um das entsprechende Modul zu starten.

curl http://127.0.0.1:9080/apisix/admin/routes -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X POST -d '
{
    "uri": "/consul/*",
    "upstream": {
        "service_name": "http://consul-server1:8500/v1/kv/upstreams/webpages/",
        "type": "roundrobin",
        "discovery_type": "consul_kv"
    }
}'

Testen und Ergebnis überprüfen

Die Anfrageergebnisse zeigen, dass die neue Route in Apache APISIX in der Lage ist, die richtige Dienstadresse über Consul zu finden und basierend auf der Lastausgleichsrichtlinie Anfragen an beide Knoten zu senden.

# erste Anfrage
curl -s http://127.0.0.1:9080/consul/
# Ausgabe
hello web1%

# zweite Anfrage
curl -s http://127.0.0.1:9080/consul/
# Ausgabe
hello web2%

# Hinweis: Es ist auch möglich, dass beide Anfragen dasselbe Ergebnis wie web1 oder web2 zurückgeben.
#       Dies liegt an der Natur des Lastausgleichs, und Sie können versuchen, mehr Anfragen zu stellen.

Zusammenfassung

Die erste Hälfte dieses Artikels beschreibt, wie Apache APISIX mit Consul zusammenarbeitet, um das auf Consul KV basierende Service-Discovery-Register zu implementieren, um das Problem der Dienstinformationsverwaltung und -wartung zu lösen. Die zweite Hälfte des Artikels konzentriert sich darauf, wie Apache APISIX in Docker mit Consul verwendet wird. Natürlich muss die Anwendung im tatsächlichen Szenario entsprechend dem Geschäftsszenario und der bestehenden Systemarchitektur analysiert werden.

Weitere Anweisungen zur Verwendung des Consul-Registers in Apache APISIX finden Sie in der offiziellen Dokumentation.

Apache APISIX arbeitet derzeit auch an zusätzlichen Plugins, um die Integration weiterer Dienste zu unterstützen. Wenn Sie interessiert sind, können Sie gerne eine Diskussion in GitHub Discussion starten oder über die Mailingliste kommunizieren.

Tags:
APISIX Basics
API Gateway Concept
Consul
Share article link