精华内容
参与话题
问答
  • Kong 网关

    2019-04-06 13:54:00
  • kong 网关教程入门

    万次阅读 2018-12-27 17:04:03
    helm 安装 先创建pv kind: PersistentVolume ... name: kong-postgre labels: release: stable spec: capacity: storage: 8Gi accessModes: - ReadWriteOnce persistentVolum...
    
        
    
    

    全栈工程师开发手册 (作者:栾鹏)
    架构系列文章


    为什么使用API-Gateway

    1. 方便客户端维护-- 每个请求方不用管理多个api url,统一访问api-gateway即可

    2. 接口重构时调用方不须了解接口本身等拆分和聚合

    3. 客户端无须关心接口协议

    4. 统一权限控制、接口请求访问日志统计

    5. 安全,是保护内部服务而设计的一道屏障

    5. 开源-最大好处

    当然也有一个很大的缺点,api-gw很可能成为性能瓶颈,因为所有的请求都经过这里,可以通过横向扩展和限流解决这个问题。

    在众多API GATEWAY框架中,Mashape开源的高性能高可用API网关和API服务管理层——KONG(基于NGINX)特点尤为突出,它可以通过插件扩展已有功能,这些插件(使用lua编写)在API请求响应循环的生命周期中被执行。于此同时,KONG本身提供包括HTTP基本认证、密钥认证、CORS、TCP、UDP、文件日志、API请求限流、请求转发及NGINX监控等基本功能。目前,Kong在Mashape管理了超过15,000个API,为200,000开发者提供了每月数十亿的请求支持。

    Kong是一款基于Nginx_Lua模块写的高可用,由于Kong是基于Nginx的,所以可以水平扩展多个Kong服务器,通过前置的负载均衡配置把请求均匀地分发到各个Server,来应对大批量的网络请求。

    在这里插入图片描述

    kong架构

    在这里插入图片描述

    Kong主要有三个组件:

    Kong Server :基于nginx的服务器,用来接收API请求。
    Apache Cassandra/PostgreSQL :用来存储操作数据。
    Kong dashboard:官方推荐UI管理工具,当然,也可以使用 restfull 方式 管理admin api。

    Kong采用插件机制进行功能定制,插件集(可以是0或N个)在API请求响应循环的生命周期中被执行。插件使用Lua编写,目前已有几个基础功能:HTTP基本认证、密钥认证、CORS(Cross-Origin Resource Sharing,跨域资源共享)、TCP、UDP、文件日志、API请求限流、请求转发以及Nginx监控。

    Kong网关的特性

    Kong网关具有以下的特性:

    可扩展性: 通过简单地添加更多的服务器,可以轻松地进行横向扩展,这意味着您的平台可以在一个较低负载的情况下处理任何请求;
    模块化: 可以通过添加新的插件进行扩展,这些插件可以通过RESTful Admin API轻松配置;
    在任何基础架构上运行: Kong网关可以在任何地方都能运行。您可以在云或内部网络环境中部署Kong,包括单个或多个数据中心设置,以及public,private 或invite-only APIs。

    在这里插入图片描述

    Kong核心基于OpenResty构建,实现了请求/响应的Lua处理化;
    Kong插件拦截请求/响应,如果接触过Java Servlet,等价于拦截器,实现请求/响应的AOP处理;
    Kong Restful 管理API提供了API/API消费者/插件的管理;
    数据中心用于存储Kong集群节点信息、API、消费者、插件等信息,目前提供了PostgreSQL和Cassandra支持,如果需要高可用建议使用Cassandra;
    Kong集群中的节点通过gossip协议自动发现其他节点,当通过一个Kong节点的管理API进行一些变更时也会通知其他节点。每个Kong节点的配置信息是会缓存的,如插件,那么当在某一个Kong节点修改了插件配置时,需要通知其他节点配置的变更。

    Kong网关插件

    身份认证插件:Kong提供了Basic Authentication、Key authentication、OAuth2.0 authentication、HMAC authentication、JWT、LDAP authentication认证实现。
    安全控制插件:ACL(访问控制)、CORS(跨域资源共享)、动态SSL、IP限制、爬虫检测实现。
    流量控制插件:请求限流(基于请求计数限流)、上游响应限流(根据upstream响应计数限流)、请求大小限制。限流支持本地、Redis和集群限流模式。
    分析监控插件:Galileo(记录请求和响应数据,实现API分析)、Datadog(记录API Metric如请求次数、请求大小、响应状态和延迟,可视化API Metric)、Runscope(记录请求和响应数据,实现API性能测试和监控)。
    协议转换插件:请求转换(在转发到upstream之前修改请求)、响应转换(在upstream响应返回给客户端之前修改响应)。
    日志应用插件:TCP、UDP、HTTP、File、Syslog、StatsD、Loggly等。

    Kong网关请求流程

    为了更好地理解系统,这是使用Kong网关的API接口的典型请求工作流程:

    在这里插入图片描述

    请求流程

    当Kong运行时,每个对API的请求将先被Kong命中,然后这个请求将会被代理转发到最终的API接口。在请求(Requests)和响应(Responses)之间,Kong将会执行已经事先安装和配置好的任何插件,授权您的API访问操作。Kong是每个API请求的入口点(Endpoint)。

    helm 安装

    先创建pv

    kind: PersistentVolume
    apiVersion: v1
    metadata:
      name: kong-postgre
      labels:
        release: stable
    spec:
      capacity:
        storage: 8Gi
      accessModes:
        - ReadWriteOnce
      persistentVolumeReclaimPolicy: Recycle
      hostPath:
        path: /data/pv/kong/postgre
    

    使用helm安装kong

    helm install stable/kong
    

    再创建kong-dashboard

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: kong-dashboard-deployment    
    spec:  
      selector:    
        matchLabels:
          app: kong-dashboard-pod  
          version: v1.0.0
      replicas: 1  
      template: 
        metadata:
          labels:
            app: kong-dashboard-pod 
            version: v1.0.0
        spec: 
          volumes: 
          - name: tz-config
            hostPath:
              path: /usr/share/zoneinfo/Asia/Shanghai
    
          containers:
          - name: kong-dashboard-container    
            image: pgbi/kong-dashboard   
            ports:    
            - containerPort: 8080
            args: 
            - 'start'
            - '--kong-url'
            - 'http://my-kong-kong-admin:8444'
            - '--insecure'
    #        - '--basic-auth'
    #        - 'intellif=introcks'
    #        command: ['sleep','30000']    
            volumeMounts:
            - name: tz-config
              mountPath: /etc/localtime
    ---
    apiVersion: v1
    kind: Service         
    metadata:            
      name: kong-dashboard-service  
    spec:           
      type: NodePort     
      ports:
      - port: 8080    
        targetPort: 8080  
        protocol: TCP
        nodePort: 31500
        name: http-kong-dashboard
      selector:
        app: kong-dashboard-pod 
        version: v1.0.0
    
      
    

    默认情况下,KONG监听的端口为:

    · 8000:此端口是KONG用来监听来自客户端传入的HTTP请求,并将此请求转发到上有服务器;

    · 8443:有的地方使用8443代替8000, 此端口是KONG用来监听来自客户端传入的HTTP请求的。它跟8000端口的功能类似,但是它只是用来监听HTTP请求的,没有转发功能。可以通过修改配置文件来禁止它;

    · 8001:Admin API,通过此端口,管理者可以对KONG的监听服务进行配置;

    · 8444:有的地方使用8444代替8001,通过此端口,管理者可以对HTTP请求进行监控.

    如果不想使用postgre数据库,可以自己进入容器配置,或者将配置文件通过configmap挂载进去

    # 示例配置位置
    /config/local_example.js
    
    # 拷贝一份
    cd ./config/
    cp local_example.js ./local.js
    
    # 配置默认数据库
    vi ./local.js
    models: {
        connection: process.env.DB_ADAPTER || 'localDiskDb',
    },
    # 改成
    models: {
        connection: process.env.DB_ADAPTER || 'mysql', // 这里可以用‘mysql’,‘mongo’,‘sqlserver’,‘postgres’
    },
    # 保存
    
    # 修改数据库默认配置
    vi connections.js
    mysql: {
        adapter: 'sails-mysql',
        host: process.env.DB_HOST || 'localhost',
        port: process.env.DB_PORT || 3306,
        user: process.env.DB_USER || 'root',
        password: process.env.DB_PASSWORD || null,
        database: process.env.DB_DATABASE || 'konga_database'
    },
    # 改成
    mysql: {
        adapter: 'sails-mysql',
        host: process.env.DB_HOST || 'localhost',
        port: process.env.DB_PORT || 3306,
        user: process.env.DB_USER || 'root',
        password: process.env.DB_PASSWORD || 'root',
        database: process.env.DB_DATABASE || 'konga_database'
    },
    # 保存
    
    # 创建数据库
    mysql -uroot -proot // 这里不建议用明文密码
    CREATE DATABASE konga_database CHARACTER SET utf8 COLLATE utf8_general_ci;
    
    

    向kong中配置一个服务

    在这一节,你会添加一个API到Kong.为了达到这个目的,首先你需要添加一个服务(Service),这是Kong用来指定它管理的上游Api和微服务的名称。

    为了达成目标,我们将会创建一个Service指向Mockbin API,MockBin是一个"回显"类型的公共网站,它返回请求者的请求,作为响应。这非常有助于我们学习Kong如何代理你的API请求。

    在你开始请求Service之前,你需要先添加一个Route。Route定义了请求在到达Kong以后如何发送到他们的Service.一个Service可以有多个Route.

    在配置完Service和Route以后,你就可以通过Kong使用他们发送请求啦。

    Kong暴露了一个RESTful管理Api在8001端口上,Kong的配置,包括添加Service和Route,都是通过这个Api发送请求.

    1. 使用管理Api添加你的Service

    执行以下cURL请求,添加你的第一个Service(指向Mockbin API):

    $ curl -i -X POST \
      --url http://localhost:8001/services/ \
      --data 'name=example-service' \
      --data 'url=http://mockbin.org'
    
    1. 为服务添加一个路由
    $ curl -i -X POST \
      --url http://localhost:8001/services/example-service/routes \
      --data 'hosts[]=example.com'
    
    1. 通过Kong转发你的请求
      执行下面的cURL请求,验证Kong是否正确转发到你的Service. 注意,默认情况下,Kong在8000端口处理代理请求.
        $ curl -i -X GET \
      --url http://localhost:8000/ \
      --header 'Host: example.com'
    

    成功响应意味着现在Kong已经将http://localhost:8000转发到我们在第一步中配的url上,并且将响应转发给我们。Kong之所以知道这么干,是通过在cURL请求里定义的Header:

    Host: <given host>
    

    启动插件

    下面的步骤中,你会配置key-auth插件,为你的Service添加认证功能。在添加这个插件之前,你的Service所有的请求都会代理到上游。一旦你添加配置了这个插件,只有带正确的API key的请求会被代理,其他的请求会被Kong拒绝,从而保护你的上游服务免于未授权调用。

    1. 配置key-auth插件

    为你在Kong中配置的服务配置key-auth插件,执行以下cURL请求 执行以下cURL请求,添加你的第一个Service(指向Mockbin API):

    $ curl -i -X POST \
      --url http://localhost:8001/services/example-service/plugins/ \
      --data 'name=key-auth'
    

    注意: 这个插件同时接受config.key_names参数,默认值是[‘apiKey’]这是一个header参数名数组,用于在请求时发送apiKey,任意一个都支持.

    1. 验证插件是否正确配置
      执行以下的cURL请求,验证key-auth插件是否在Service上正确配置:

    你会收到一个类似下面的响应:

    $ curl -i -X GET \
      --url http://localhost:8000/ \
      --header 'Host: example.com'
    

    由于你没有在header或参数里添加指定需要的apiKey,响应应该是401 Unauthorized

    HTTP/1.1 401 Unauthorized
    ...
    
    {
      "message": "No API key found in request"
    }
    

    添加信任用户Consumer

    1. 通过RESTful API创建一个Consumer
      执行下面的命令,创建一个叫Jason的用户
    $ curl -i -X POST \
      --url http://localhost:8001/consumers/ \
      --data "username=Jason"
    

    响应大致如下:

    HTTP/1.1 201 Created
    Content-Type: application/json
    Connection: keep-alive
    
    {
      "username": "Jason",
      "created_at": 1428555626000,
      "id": "bbdf1c48-19dc-4ab7-cae0-ff4f59d87dc9"
    }
    

    恭喜,你刚添加了第一个Consumer

    提示 Kong同时接受custom_id参数,关联到库中已存在的Consumer

    1. 为Consumer发放凭证
      给刚创建的用户Jason创建 一个key
    $ curl -i -X POST \
      --url http://localhost:8001/consumers/Jason/key-auth/ \
      --data 'key=ENTER_KEY_HERE'
    
    1. 验证你的Consumer凭证有效
      现在,我们可以执行下面的命令,验证刚刚给Jason发放的凭证是否有效.
    $ curl -i -X GET \
      --url http://localhost:8000 \
      --header "Host: example.com" \
      --header "apikey: ENTER_KEY_HERE"
    

    参考:https://www.pocketdigi.com/book/kong/guides/configuration-reference.html

    Kong API Gateway 管理API详解

    使用api,我们可以编程控制网关。这也是kong-dashboard做的事情。

    参考:https://linuxops.org/blog/kong/admin.html

    展开全文
  • KONG网关 — 介绍安装

    千次阅读 2019-04-30 16:46:04
    公共网关屈指可数,其中最受关注的就是KONG了,笔者半年前就已经在使用kong的那时候使用的是0.11.2-bate版本(之前还被官方坑了一次),前不久终于等到了1.X的正式版发布了,笔者就在这里给大家分享一下kong网关的...

    网关是微服务中不可或缺的一部分,它承载了所有请求流量入口,参数验证拦截,用户权限验证,但是除了JAVA的spring cloud之外,公共网关屈指可数,其中最受关注的就是KONG了,笔者半年前就已经在使用kong的那时候使用的是0.11.2-bate版本(之前还被官方坑了一次),前不久终于等到了1.X的正式版发布了,笔者就在这里给大家分享一下kong网关的基本情况以及使用安装的方式。

    附上:

    喵了个咪的博客:w-blog.cn

    kong官网:https://konghq.com/

    PS:本文使用的是Kong1.0.3版本

    一,kong是什么

    kong在girhub有不小的人气,star都有2W多次了相比也知道大家对于kong的热爱(确实也不使用JAVA栈没有什么好的选择),从下面这张官方配图可以看出,kong把本身每个服务都需要重复编写的操作汇总到了一起,让业务关注业务实现不用在为很多的规则进行重复的处理。

    从笔者总结数来kong的主要优势:

    • 插件市场丰富,很多插件可以降低开发成本;
    • 可扩展性,可以编写lua脚本来定制自己的参数验证权限验证等操作;
    • 基于openResty,openResty基于Nginx保障了强劲的性能;
    • 便捷性能扩容,只需要水平增加服务器资源性能就能提升 ;
    • 负载均衡健康检查

    二,Docket部署kong

    PS:postgreSql数据库版本必须 > 9.4

    因为不是通过docker-composer启动的容器需要互相访问需要在同一个网络名下才可以互相访问

    docker network create kong-net
    

    数据库使用 postgres

    docker run -d --name kong-database \
                   --network=kong-net \
                   -p 5432:5432 \
                   -e "POSTGRES_USER=kong" \
                   -e "POSTGRES_DB=kong" \
                   postgres:9.6
    

    准备数据库数据和配置,只需要运行一遍运行完成后会自动结束

    docker run --rm \
         --network=kong-net \
         -e "KONG_DATABASE=postgres" \
         -e "KONG_PG_HOST=kong-database" \
         -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
         kong:1.0.3 kong migrations bootstrap
    

    启动kong-service

    docker run -d --name kong \
         --network=kong-net \
         -e "KONG_DATABASE=postgres" \
         -e "KONG_PG_HOST=kong-database" \
         -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
         -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
         -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
         -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
         -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
         -e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl" \
         -p 8000:8000 \
         -p 8443:8443 \
         -p 8001:8001 \
         -p 8444:8444 \
         kong:1.0.3
    
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                                                NAMES
    d82c2b7729ae        kong:1.0.3          "/docker-entrypoin..."   3 seconds ago       Up 2 seconds        0.0.0.0:8000-8001->8000-8001/tcp, 0.0.0.0:8443-8444->8443-8444/tcp   kong
    9b7f5a9c808f        postgres:9.6        "docker-entrypoint..."   26 seconds ago      Up 25 seconds       0.0.0.0:5432->5432/tcp                                               kong-database
    

    然后调用了一下地址有输出即可:

    curl -i http://localhost:8001/
    

    使用docker-compose部署kong

    version: '2.1'
    services:
      kong-migrations:
        image: "kong:1.0.3"
        command: kong migrations bootstrap
        depends_on:
          db:
            condition: service_healthy
        environment:
          KONG_DATABASE: postgres
          KONG_PG_DATABASE: kong
          KONG_PG_HOST: db
          KONG_PG_PASSWORD: kong
          KONG_PG_USER: kong
        links:
          - db:db
      kong:
        image: "kong:1.0.3"
        depends_on:
          db:
            condition: service_healthy
        environment:
          KONG_ADMIN_ACCESS_LOG: /dev/stdout
          KONG_ADMIN_ERROR_LOG: /dev/stderr
          KONG_ADMIN_LISTEN: '0.0.0.0:8001'
          KONG_CASSANDRA_CONTACT_POINTS: db
          KONG_DATABASE: postgres
          KONG_PG_DATABASE: kong
          KONG_PG_HOST: db
          KONG_PG_PASSWORD: kong
          KONG_PG_USER: kong
          KONG_PROXY_ACCESS_LOG: /dev/stdout
          KONG_PROXY_ERROR_LOG: /dev/stderr
        links:
          - db:db
        ports:
          - "8000:8000/tcp"
          - "8001:8001/tcp"
          - "8443:8443/tcp"
          - "8444:8444/tcp"
        restart: on-failure
      db:
        image: postgres:9.6
        environment:
          POSTGRES_DB: kong
          POSTGRES_PASSWORD: kong
          POSTGRES_USER: kong
        healthcheck:
          test: ["CMD", "pg_isready", "-U", "kong"]
          interval: 30s
          timeout: 30s
          retries: 3
        restart: on-failure
        stdin_open: true
        tty: true
    

    db的 healthcheck 做了数据层初始化完成检测,数据库完成之后才会按照顺序继续启动接下来的容器

    docker-compose up -d
    

    三,使用外部数据库

    很多使用我们并不在容器中运行DB实例,因为如果出现任何问题数据丢失,我们先准备好对应的postgres数据库

    {DB-host}:{DB-port}
    {DB-user}
    {DB-pass}
    

    创建数据库

    CREATE DATABASE "kong" WITH ENCODING='UTF8';
    

    初始化kong需要的数据库

    version: '2.1'
    services:
      kong-migrations:
        image: "kong:1.0.3"
        command: kong migrations bootstrap
        environment:
          KONG_DATABASE: postgres
          KONG_PG_DATABASE: kong
          KONG_PG_HOST: {DB-host}
          KONG_PG_PORT: {DB-port}
          KONG_PG_PASSWORD: {DB-pass}
          KONG_PG_USER: {DB-user}
    
    > docker-compose up -d
    Creating network "kong_default" with the default driver
    Creating kong_kong-migrations_1 ...
    Creating kong_kong-migrations_1 ... done
    

    在通过docker-compose来运行kong服务

    version: '2.1'
    services:
      kong:
        image: "kong:1.0.3"
        environment:
          KONG_ADMIN_ACCESS_LOG: /dev/stdout
          KONG_ADMIN_ERROR_LOG: /dev/stderr
          KONG_ADMIN_LISTEN: '0.0.0.0:8001'
          KONG_CASSANDRA_CONTACT_POINTS: db
          KONG_DATABASE: postgres
          KONG_PG_DATABASE: kong
          KONG_PG_HOST: {DB-host}
          KONG_PG_PORT: {DB-port}
          KONG_PG_PASSWORD: {DB-pass}
          KONG_PG_USER: {DB-user}
          KONG_PROXY_ACCESS_LOG: /dev/stdout
          KONG_PROXY_ERROR_LOG: /dev/stderr
        ports:
          - "8000:8000/tcp"
          - "8001:8001/tcp"
          - "8443:8443/tcp"
          - "8444:8444/tcp"
        restart: on-failure
    
    docker-compose up -d
    Creating kong_kong_1 ...
    Creating kong_kong_1 ... done
    

    kubernetes编排

    apiVersion: extensions/v1beta1                  # K8S对应的API版本
    kind: Deployment                                # 对应的类型
    metadata:
      name: kong
      labels:
        name: kong
      namespace: kong                                # namespace
    spec:
      replicas: 1                                   # 镜像副本数量
      template:
        metadata:
          labels:                                   # 容器的标签 可和service关联
            app: kong
        spec:
          containers:
            - name: kong                        # 容器名和镜像
              image: kong:1.0.3
              imagePullPolicy: Always
              ports:
              - containerPort: 8000
              env:                                  # 环境变量
              - name: KONG_DATABASE
                value: postgres
              - name: KONG_PG_DATABASE
                value: dev-kong
              - name: KONG_PG_HOST
                value: {DB-host}
              - name: KONG_PG_PORT
                value: {DB-port}
              - name: KONG_PG_PASSWORD
                value: {DB-pass}
              - name: KONG_PG_USER
                value: {DB-user}
              - name: KONG_LOG_LEVEL
                value: warn
              resources:                            # 资源限制
                requests:
                  memory: "256Mi"
                  cpu: "200m"
                limits:
                  memory: "512Mi"
                  cpu: "400m"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      namespace: kong                                  # 在哪个命名空间中创建
      name: kong                          # 名称
      labels:
        name: kong
    spec:
      type: NodePort                                  # 开放端口的类型
      selector:                                       # service负载的容器需要有同样的labels
        app: kong
      ports:
      - name: http
        port: 8000                                    # 通过service来访问的端口
        targetPort: 8000                              # 对应容器的端口
        nodePort: 30180
      - name: https
        port: 8443                                    # 通过service来访问的端口
        targetPort: 8443                              # 对应容器的端口
        nodePort: 30143
      - name: api
        port: 8001                                    # 通过service来访问的端口
        targetPort: 8001                              # 对应容器的端口
        nodePort: 30801
    
    展开全文
  • KONG网关 — 插件开发

    千次阅读 2019-05-10 16:30:54
    在很多系统中不可能吧用户体系用到kong提供的权限验证体系,包括对于一套系统完整的RBAC系统大家都有不同的改进,以及请求加密参数校验等等,所以对于扩展性对于网关的定义需要有一定的能力的,kong是通过nginx+lua...

    虽然kong提供了那么多的插件,但是不可能百分百满足了对于网关的需求,在很多系统中不可能吧用户体系用到kong提供的权限验证体系,包括对于一套系统完整的RBAC系统大家都有不同的改进,以及请求加密参数校验等等,所以对于扩展性对于网关的定义需要有一定的能力的,kong是通过nginx+lua开发的通过lua脚本就可以扩展插件来完成网关的目的

    附上:

    喵了个咪的博客:w-blog.cn

    kong官网:https://konghq.com/

    konga官网:https://github.com/pantsel/konga

    PS:Kong版本必须 >= 1.0.0才能正常使用konga

    一,开发环境准备

    首先需要开发环境,docker并不适合作为开发环境来使用,容器重启内容丢失等问题对kong-lua插件开发来说不友好,容器内部的结构也存在区别,所以我们需要使用liunx机器来进行开发

    wget https://bintray.com/kong/kong-community-edition-rpm/download_file?file_path=centos/7/kong-community-edition-1.0.3.el7.noarch.rpm
    
    sudo yum install epel-release
    sudo yum install kong-community-edition-1.0.3.el7.noarch.rpm --nogpgcheck
    
    kong version
    1.0.3
    

    准备数据库

    mkdir -p /app/docker/postgres
    cd /app/docker/postgres/
    vim docker-compose.yml
    
    version: '2.1'
    services:
      db:
        image: postgres:9.6
        environment:
          POSTGRES_DB: kong
          POSTGRES_PASSWORD: kong
          POSTGRES_USER: kong
        healthcheck:
          test: ["CMD", "pg_isready", "-U", "kong"]
          interval: 30s
          timeout: 30s
          retries: 3
        restart: on-failure
        stdin_open: true
        tty: true
        ports:
          - "5432:5432/tcp"
    
    docker-compose up -d
    

    初始化配置文件

    cp /etc/kong/kong.conf.default /etc/kong/kong.conf
    vim /etc/kong/kong.conf
    

    按照之前运营容器时候注入的环境变量来修改配置文件

    admin_access_log = logs/admin_access.log
    admin_error_log = logs/error.log 
    admin_listen = 0.0.0.0:8001
    database = postgres
    pg_database = kong
    pg_host = 127.0.0.1
    pg_password = kong
    pg_user = kong
    

    启动kong,初始化数据库

    kong migrations bootstrap -c /etc/kong/kong.conf
    

    启动kong

    kong start -c /etc/kong/kong.conf
    

    访问kong

    curl localhost:8001
    

    运行konga

    docker run -p 1337:1337 \
                 --name konga \
                 -e "NODE_ENV=production" \
                 pantsel/konga:0.14.1
    

    最后就是使用你常用的idea装好lua扩展就可以了

    二、开发扩展

    这两个文件是必须有的

     handler.lua   // 一个实现的接口。每个函数都由Kong在请求的生命周期中的所需时刻运行。
     schema.lua    // 保存插件配置的架构,以便用户只能输入有效的配置值。
    

    还有其他的扩展文件

    complete-plugin
    ├── api.lua             // 定义Admin API中可用的端点列表,以与插件处理的实体自定义实体进行交互。
    ├── daos.lua            // 定义DAO(数据库访问对象)列表,这些DAO是插件所需并存储在数据存储区中的自定义实体的抽象。
    ├── handler.lua         
    ├── migrations          // 给定数据存储的相应迁移。只有当您的插件必须在数据库中存储自定义实体并通过 daos.lua定义的其中一个DAO与它们进行交互时,才需要进行迁移。
    │ ├── cassandra.lua
    │ └── postgres.lua
    └── schema.lua
    
    mkdir http-rewrite
    cd http-rewrite
    vim handler.lua
    vim schema.lua
    
    return {
        no_consumer = true,
        fields = {
            regex = { type = "string" },
            replacement = { type = "string" },
            flag = {type = "string"},
        },
        self_check = function(schema, plugin_t, dao, is_update)
            -- TODO: add check
            return true
        end
    }
    
    local BasePlugin = require "kong.plugins.base_plugin"
    local json = require("cjson")
    local RewriteHandler = BasePlugin:extend()
    local ngx = ngx
    
    RewriteHandler.PRIORITY = 2000
    RewriteHandler.VERSION = "0.1.0"
    
    -- 传入参数conf是这个插件存放在数据库中配置
    function RewriteHandler:access(conf)
        RewriteHandler.super.access(self)
    
        local host = ngx.var.host
        ngx.log(ngx.DEBUG, "http-rewrite plugin, host is: ", host, " ,uri is: ",
            ngx.var.request_uri, " ,config is: ", json.encode(conf))
    
        local replace,n,err  = ngx.re.sub(ngx.var.request_uri, conf.regex, conf.replacement)
        if replace and n == 0 then
            return
        end
    
        if err then
            ngx.log(ngx.ERR, "http-rewrite plugin, ngx.re.sub err: ",err, " ,host is: ", host, " ,uri is: ",
                ngx.var.request_uri, " ,config is: ", json.encode(conf))
            return
        end
    
        ngx.log(ngx.DEBUG, "http-rewrite plugin, replace is: ",replace)
        if conf.flag == "redirect" then
            ngx.redirect(replace,302)
        elseif conf.flag == "permanent" then
            ngx.redirect(replace,301)
        end
    end
    
    function RewriteHandler:new()
        RewriteHandler.super.new(self, "http-rewrite")
    end
    
    return RewriteHandler
    
    ## 在使用新插件之前,需要更新一下数据库:
    kong migrations up -c /etc/kong/kong.conf
    kong start -c /etc/kong/kong.conf
    

    开启插件

    此时就开启了我们自己开发的插件了

    也可以通过konga工具开启

    配置可以在其中看到

    此时访问
    http://172.16.1.82:8000/abc/test
    会被跳转到
    http://172.16.1.82:8000/redirect//test

    到这里就已经完成了一个基础插件的开发,更多的一些系统函数可以通过官方插件开发手册来使用

    展开全文
  • Kong网关介绍

    千次阅读 2019-09-28 19:33:35
    传统服务如下左图,通用函数重复使用在多个服务中,系统庞大僵化难以管理,由于会冲击其他服务导致的扩展困难,由于系统限制导致生产率低,如下右图是kong的解决方案 kong特点: 云原生:平台无关,kong可以在...
  • Kong网关安装

    2019-08-30 15:18:55
    环境 系统:CentOS 7 x64 虚拟机:VmwareVMware Workstation Pro15.1.0 build-13591040 安装文档参考官网:... 配置yum; 方...
  • 安装 Kong 网关

    2020-07-13 20:06:00
    快速入门PostgreSQLKong可以在有或没有数据库的情况下运行,这里我们使用数据库的方式进行运行。Kong支持PostgreSQL 9.5+和Cassandra 3.xx数据...
  • 为什么kong这么火热呢?当然是它拥有强大的插件群来解决我们本来需要重复手动配置或者需要自己实现的内容,kong在1.X版本加强了对于插件的支持,官方提供的插件就是几十个,通过插件可以带来各种场景更加方便使用 ...
  • API网关之Kong网关简介

    万次阅读 2018-07-31 19:04:54
    1. Kong简介 Kong是一款基于OpenResty(Nginx + Lua模块)编写的高可用、易扩展的,由Mashape公司开源的API Gateway项目。Kong是基于NGINX和Apache Cassandra或PostgreSQL构建的,能提供易于使用的RESTful API来...
  • KONG网关 — KongA管理UI使用

    千次阅读 2019-05-05 11:21:43
    kong虽然很强大,但是在管理方式上比较单一只能通过API请求来管理,那么有没有一个UI界面的管理工具呢?这里就要说到kong管理UI新起之秀Konga 附上: 喵了个咪的博客:w-blog.cn kong官网:https://konghq.com/ konga...
  • Kong网关插件

    千次阅读 2020-07-06 10:08:52
    今天的一个重点就是要加强对 Kong API Gateway 网关的研究,对于 Kong 网关之前写过两篇文章,今天重点谈下 Kong 网关的插件支持能力。 从上面图可以看到,Kong 网关是基于 OpenResty 应用服务器,OpenResty 是一个...
  • Kong网关插件使用

    千次阅读 2020-07-06 10:50:14
    在接口请求中权限验证是一个恒久不变的话题,Kong 自带了6种加密方式 先创建一个 Basic Auth,直接确认即可 此时页面访问 http://dev.lyafei.com:8000/dev 会弹出登录框,让你输入用户名密码,若取消则会返回{...
  • Kong网关简介安装

    千次阅读 2020-07-08 10:15:45
    背景 我们有批设备卖给了海外的服务商,老外请了第三方检测机构,检测设备与我们系统的安全...网关是微服务中不可或缺的一部分,它承载了所有请求流量入口,参数验证拦截,用户权限验证等,但是除了 JAVA 的 spring c.
  • Kong 网关使用入门

    千次阅读 2019-06-19 06:16:50
    Kong是一款基于Nginx_Lua模块写的高可用网关API,通过前置的负载均衡配置把请求均匀地分发到各个Server,来应对大批量的网络请求。基于Nginx 特性,Kong本身也非常容易地扩展到多个服务器上。 Kong主要有三个组件: ...
  • kong网关集群部署

    2020-03-11 23:15:49
    kong网关集群部署机器准备节点A部署1.安装依赖组件2.安装postgresql3.创建kong数据库4.安装kong5.安装可视化界面konga6.konga部署在生产环境节点B部署1.安装kong测试集群效果 机器准备 节点A 192.168.0.1 节点B 192....
  • Kong 网关 | Route

    2020-01-18 19:25:35
    一、简介 路由用来匹配客户端向上游服务器请求的规则,也就是客户端调用的 API,每个路由(Route)和一个服务(Service) 相关联,一个服务可有有多个路由,我们可以对每一条路由进行细粒度的配置,可以使用正则表达式...
  • Kong 网关 | Service

    2020-01-17 20:46:32
    服务 Service 是 Kong 对上游服务的抽象,也就是我们的一个个微服务,一个个项目,它用来管理上游服务的 API在创建一个上游的 API 之前,需要创建一个服务。 二、相关属性 kong 配置一个服务需要设置的相关属性,...
  • docker安装kong网关

    2020-11-19 11:44:48
    参考官方说明: ...前期准备: 需要一个数据库做配置支持,这里选择pg10 ...docker run -d --name kong-database –network=kong-net -p 5432:5432 -e “POSTGRES_USER=kong” -e “POSTGRES_DB=kong” -e “POSTGR
  • 主要介绍了docker安装kong网关的方法示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 开发的生活有了Docker之后,一切都变得爽YY了。可以有更多时间回家陪老人孩子。下面介绍下如何使用Docker和k8s部署Kong。 Docker部署Kong脚本: 1、安装Docker yum install docker;systemctl enable doc...

空空如也

1 2 3 4 5 ... 20
收藏数 4,599
精华内容 1,839
关键字:

kong网关