Utiliser OpenResty pour implémenter une passerelle API hautes performances dans Beego

En tant que framework d'application Web, Beego a déjà acquis une certaine réputation dans le cercle du langage Go. Il fournit un routage HTTP riche, une journalisation, un ORM et d'autres fonctions, facilitant le développement d'applications Web. Alors, si l’on souhaite mettre en place une passerelle API performante, peut-on utiliser Beego pour y parvenir ? La réponse est oui. Cet article expliquera comment utiliser OpenResty pour implémenter une passerelle API hautes performances dans Beego.

Qu'est-ce qu'API Gateway ?

La passerelle API est une couche intermédiaire située entre le port de service et le client. Elle est utilisée pour connecter plusieurs services back-end et fournir des interfaces API simples avec le monde extérieur. Dans l'architecture des microservices, en raison du grand nombre de services et des protocoles de service incohérents, nous avons souvent besoin d'une passerelle API pour transférer et convertir différents services.

Lors de la mise en œuvre de la passerelle API, nous devons prendre en compte les trois aspects suivants :

1. Prise en charge de plusieurs protocoles. Les services backend peuvent utiliser différents protocoles, tels que HTTP, WebSocket, gRPC, etc. La passerelle API doit prendre en charge ces protocoles et être capable de les convertir en une interface API unifiée.
2. Équilibrage de charge et tolérance aux pannes. La passerelle API doit mettre en œuvre des mécanismes d'équilibrage de charge et de tolérance aux pannes pour garantir une haute disponibilité et des performances élevées des services back-end.
3. Considérations de sécurité. La passerelle API doit fournir des fonctionnalités de sécurité telles que l'autorisation, l'authentification et le contrôle d'accès pour garantir la fiabilité et la sécurité des services back-end.

Introduction à OpenResty

OpenResty est un serveur d'applications Web basé sur Nginx, développé par le programmeur chinois Zhang Yichun. Il étend Nginx pour prendre en charge le langage de script Lua, permettant une expansion dynamique hautes performances. OpenResty se caractérise par ses hautes performances. Il atteint une concurrence élevée et une faible latence en mettant en cache les ressources statiques en mémoire et en utilisant des technologies telles que les coroutines.

Dans cet article, nous utiliserons OpenResty comme composant principal de la passerelle API, et Beego pour implémenter une logique de routage et de contrôle pour la gestion des services back-end. Cela présente deux avantages : premièrement, vous pouvez utiliser pleinement les fonctionnalités hautes performances d'OpenResty pour améliorer la vitesse de réponse et la concurrence de la passerelle API ; deuxièmement, vous pouvez utiliser Beego pour gérer le routage et la configuration des services back-end ; réduisant la complexité du développement. Vous pouvez également profiter des propres fonctions de routage et de contrôleur de Beego.

Utilisez OpenResty pour implémenter la passerelle API dans Beego

Installez OpenResty

Avant de commencer à utiliser OpenResty, nous devons installer OpenResty et ses progiciels associés. OpenResty fournit officiellement de nombreux packages d'installation binaires pour différentes plates-formes, qui peuvent être téléchargés et installés sur son site officiel. Si vous utilisez Ubuntu/Debian, vous pouvez utiliser la commande suivante pour installer :

$ sudo apt-get install libreadline-dev libncurses5-dev libpcre3-dev libssl-dev perl make build-essential
$ wget https://openresty.org/download/openresty-1.19.3.2.tar.gz
$ tar -xzvf openresty-1.19.3.2.tar.gz
$ cd openresty-1.19.3.2
$ ./configure --with-http_realip_module --with-http_stub_status_module --with-luajit --prefix=/usr/local/openresty
$ make && sudo make install

Une fois l'installation terminée, nous devons ajouter le chemin du fichier binaire d'OpenResty à la variable d'environnement PATH du système afin que nginx, etc. peut être utilisé directement dans les composants OpenResty en ligne de commande.

$ export PATH=$PATH:/usr/local/openresty/nginx/sbin

Implémentation du routage OpenResty

Pour utiliser OpenResty dans Beego, vous devez intégrer le routage OpenResty et le routage Beego. Plus précisément, la configuration du routage de Beego est entièrement gérée par OpenResty, et Beego n'a qu'à fournir le contrôleur correspondant au routage. Dans ce processus, nous devons utiliser le script Lua d'OpenResty pour implémenter la distribution de routes.

Ce qui suit est une implémentation simple de routage OpenResty :

location /api/ {
    content_by_lua_block {
        local args = ngx.req.get_uri_args()
        if args['service'] == 'user' then
            ngx.exec('/user' .. ngx.var.request_uri)
        elseif args['service'] == 'order' then
            ngx.exec('/order' .. ngx.var.request_uri)
        else
            ngx.say('Unknown service')
            ngx.exit(400)
        end
    }
}

Dans le code ci-dessus, nous spécifions une route avec le préfixe URL /api/ via la configuration de l'emplacement. Cette route transmettra la demande au. prestations spécifiques. Les règles de transfert spécifiques dépendent du paramètre service dans la demande. Nous pouvons sélectionner différents services en fonction de différentes valeurs de paramètres pour réaliser la distribution des routes. /api/的路由，这个路由会将请求转发到具体的服务。具体的转发规则取决于请求中的service参数，我们可以根据不同的参数值，选择不同的服务，从而实现路由分发。

为了让OpenResty能够执行类似于上面的Lua脚本，我们需要将这些脚本文件存放在指定的目录下，并在nginx.conf中配置Lua脚本路径：

lua_package_path "/etc/nginx/conf.d/lua/?.lua;;";

需要注意的是，由于我们使用了ngx.exec来执行真正的服务转发，因此我们需要在对应的服务代码中指定一个更加具体的路由，以便OpenResty能够正确地进行匹配和转发。例如，我们可以指定/user和/order为具体的路由前缀，然后在路由配置中使用ngx.exec来进行转发，如下所示：

location /user/ {
    content_by_lua_block {
        ngx.exec('@user_service')
    }
}

location /order/ {
    content_by_lua_block {
        ngx.exec('@order_service')
    }
}

在这里，@user_service和@order_service

Pour qu'OpenResty exécute des scripts Lua similaires à ceux ci-dessus, nous devons stocker ces fichiers de script dans le répertoire spécifié et configurer le chemin du script Lua dans nginx.conf :

location @user_service {
    proxy_pass http://127.0.0.1:8080;
    # ...
}

location @order_service {
    proxy_pass http://127.0.0.1:8081;
    # ...
}

Il convient de noter que puisque nous utilisons ngx. exec pour effectuer un véritable transfert de service, nous devons donc spécifier une route plus spécifique dans le code de service correspondant afin qu'OpenResty puisse correspondre et transférer correctement. Par exemple, nous pouvons spécifier /user et /order comme préfixes de routage spécifiques, puis utiliser ngx.exec dans la configuration de routage pour transférer, Comme indiqué ci-dessous :

import (
    "strings"
    "github.com/astaxie/beego"
)

type ApiController struct {
    beego.Controller
}

func (this *ApiController) Handle() {
    uri := this.Ctx.Request.RequestURI
    scriptPath := "/etc/nginx/conf.d/lua" + strings.TrimSuffix(uri, ".lua") + ".lua"
    this.Ctx.Output.ServeFile(scriptPath)
}

Ici, @user_service et @order_service pointent tous deux vers l'emplacement Nginx du service spécifique. Leurs définitions sont similaires à celles-ci :

rrreee

. De cette façon, nous avons mis en œuvre un routage et un transfert simples. Cependant, ce n'est qu'une petite partie des fonctions d'OpenResty. Il possède également de nombreuses fonctions et fonctionnalités puissantes, telles que la mise en cache, le proxy inverse, la limitation de courant, etc. Dans le développement réel d'une passerelle API, nous pouvons choisir les fonctionnalités appropriées à utiliser en fonction de besoins spécifiques.

Implémentation du contrôleur Beego🎜🎜En plus du routage OpenResty, nous devons également implémenter le contrôleur et la logique métier dans Beego. Ici, nous pouvons réaliser un chargement dynamique de scripts Lua en utilisant la fonction http.ServeFile intégrée de Beego dans le contrôleur pour charger le script Lua spécifié. 🎜🎜Voici un exemple de contrôleur simple : 🎜

import (
    "strings"
    "github.com/astaxie/beego"
)

type ApiController struct {
    beego.Controller
}

func (this *ApiController) Handle() {
    uri := this.Ctx.Request.RequestURI
    scriptPath := "/etc/nginx/conf.d/lua" + strings.TrimSuffix(uri, ".lua") + ".lua"
    this.Ctx.Output.ServeFile(scriptPath)
}

在上述代码中，我们首先获取请求的URI，然后根据URI构造出对应的Lua脚本路径，并调用http.ServeFile函数将脚本内容返回给OpenResty，从而实现动态加载脚本的目的。需要注意的是，我们需要对请求的后缀进行进一步处理，将.lua后缀去掉，并在路径中添加相应的前缀，才能正确地加载脚本文件。

总结

在本文中，我们介绍了如何在Beego中使用OpenResty实现高性能API网关。通过整合Beego和OpenResty的特性，我们实现了分布式路由、负载均衡和容错等核心功能，并为了实现安全性考虑，提供了授权、认证、访问控制等安全特性。在实际应用中，API网关还需要考虑缓存、反向代理、限流等特性，我们需要根据实际需要进行选取。

总的来说，Beego和OpenResty都是非常优秀的Web应用框架，它们的优势互补，可以帮助我们快速构建高性能和高可靠的Web应用。如果你还没有尝试过使用这两个框架，不妨想一想如何将它们应用到自己的项目中，相信会为你带来不少启示。

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!