Créer une passerelle API à l'aide du langage Go

Avec la popularité de l'architecture des microservices, la passerelle API, en tant qu'élément indispensable de l'architecture des microservices, est de plus en plus appréciée par les entreprises. La passerelle API agit principalement comme une façade externe, fournit un point d'entrée et est responsable d'une série de fonctions telles que la conversion de protocole, l'équilibrage de charge distribué, l'authentification de sécurité et la gestion des API. Dans de nombreux scénarios d'application, la passerelle API résout non seulement de nombreux problèmes au niveau technique, mais offre également des avantages tels qu'une itération rapide et une expansion flexible au niveau commercial.

Cet article expliquera comment utiliser le langage Go pour créer une passerelle API basée sur Kong, notamment en utilisant Kong pour gérer les API et les plugins, et en utilisant le langage Go et l'API Kong pour exploiter la configuration Kong.

1. Introduction à Kong

Kong est une passerelle API open source qui fournit une série complète de fonctions de gestion et de sécurité des API et peut fonctionner dans une variété d'environnements. Il fournit principalement des outils de gestion tels que l'équilibrage de charge, la découverte de services, le routage, l'authentification, l'autorisation, la limitation de courant, la surveillance et les plug-ins. Kong utilise Nginx comme serveur proxy et utilise le mécanisme de plug-in pour ajouter diverses fonctions avancées au trafic HTTP. Les plug-ins de Kong peuvent être activés selon les besoins, afin que Kong puisse répondre à divers scénarios et besoins commerciaux spécifiques, ce qui le rend également très populaire.

2. Utilisez Kong pour gérer les API et les plugins

1. Installez Kong

Vous pouvez choisir différents environnements d'installation via le guide d'installation sur le site officiel de Kong. Voici Ubuntu à titre d'exemple :

$ echo "deb https://kong.bintray.com/kong-deb `lsb_release -sc` main" | sudo tee -a /etc/apt/sources.list
$ curl -o bintray.key https://bintray.com/user/downloadSubjectPublicKey?username=bintray
$ sudo apt-key add bintray.key
$ sudo apt-get update && sudo apt-get install -y kong

Après une installation réussie, le fichier de configuration Kong sera généré dans le répertoire /etc/kong.

2. Démarrez Kong

$ kong start

3. Gérer les API

Utilisez l'API d'administration de Kong pour gérer les API.

$ curl -i -X POST 
  --url http://localhost:8001/apis/ 
  --data 'name=helloworld' 
  --data 'uris=/hello' 
  --data 'upstream_url=http://example.com/hello'

L'exemple ci-dessus crée une API nommée helloworld via l'API Admin, l'URI de la route est /hello et l'adresse du serveur en amont est http://example.com/hello. De cette façon, accédez simplement à http://localhost. :8000/hello , vous pouvez accéder à http://example.com/hello.

4. Gérer les plugins

L'utilisation de Kong peut facilement ajouter des plugins, améliorant ainsi les capacités de l'API.

$ curl -i -X POST 
  --url http://localhost:8001/apis/helloworld/plugins/ 
  --data 'name=key-auth'

L'exemple ci-dessus ajoute un plug-in appelé key-auth à l'API helloworld via l'API Admin. Ce plugin est utilisé pour l'authentification basée sur la clé API.

3. Utilisez le langage Go et l'API Kong pour exploiter la configuration de Kong

En plus d'utiliser l'API Admin pour gérer les API et les plugins, vous pouvez également utiliser l'API RESTful fournie par Kong pour un contrôle plus précis. Elle est entièrement cohérente. avec le modèle de données interne de Kong, il est plus pratique de démarrer l'API Admin.

Ici, nous utiliserons le langage Go et le combinerons avec Kong Client SDK pour exploiter la configuration Kong.

1. Installer le SDK client Kong

$ go get github.com/Kong/go-kong/kong

2. Créer la configuration Kong

conf := kong.Configuration{
  KongAdminURL: "http://localhost:8001", // Kong Admin接口地址
  KongURL: "http://localhost:8000", // Kong代理服务地址
}

3. Créer l'API et la Route

api := &kong.Api{
  Name: kong.String("helloworld"),
  RequestHost: kong.String("example.com"),
  UpstreamURL: kong.String("http://example.com/hello"),
}

route := &kong.Route{
  Name: kong.String("hello-route"),
  Paths: kong.StringSlice([]string{"/hello"}),
  Methods: kong.StringSlice([]string{"GET"}),
}

Après l'avoir créé, vous pouvez utiliser le code suivant pour les associer :

service, err := kong.CreateServiceWithDefaults(conf, api) // 用默认配置创建Service
if err != nil {
  panic(err)
}

route, err = kong.CreateRouteWithDefaults(conf, route, service)
if err != nil {
  panic(err)
}

De cette façon, un est créé. Le nom est helloworld, l'URI de la route est /hello, l'adresse du serveur en amont est http://example.com/hello et la route accessible à l'aide de la requête GET.

4. Ajout d'un plugin

L'ajout d'un plugin est également très simple. Ici, nous ajoutons un plug-in d'authentification basé sur un jeton pour l'authentification des utilisateurs. Le code est le suivant :

plugin := &kong.Plugin{
  Name: kong.String("jwt"),
  Config: kong.Configuration{
    "anonymous": "true",
  },
}
route.Plugins = []*kong.Plugin{plugin}

_, err = kong.UpdateRouteWithDefaults(conf, route, service)
if err != nil {
  panic(err)
}

Ici, nous utilisons le nom du plugin comme jwt, afin que nous puissions ajouter l'authentification JWT. Ici, nous utilisons l'authentification anonyme.

Résumé

Cet article présente le processus de création d'une passerelle API à l'aide du langage Go et du SDK client Kong. En utilisant Kong, vous pouvez rapidement créer une passerelle API, gérer les API et les plug-ins et implémenter des fonctions telles que l'authentification et la limitation de courant. Kong peut être contrôlé et géré davantage à l'aide du langage Go et du SDK client Kong. Ces outils peuvent améliorer l'évolutivité et la gestion des passerelles API, permettant ainsi aux microservices de mieux servir l'entreprise.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!