Config

Pixiu supports specifying local config file with argument -c which you can find in those samples pixiu dir.

Pixiu uses the config abstraction like envoy such as listener, filter, route and cluster.

Besides, pixiu provides another dubbo-specific config named api_config, by which dubbo-filter can transform the http request to dubbo generic call. You can also find it in those samples's pixiu directory.

The document Api Model provides the api_config specification about the pixiu config abstraction.

This document mainly describes the pixiu config abstraction, there is a example below:

static_resources:
  listeners:
    - name: "net/http"
      protocol_type: "HTTP"
      address:
        socket_address:
          address: "0.0.0.0"
          port: 8888
      filter_chains:
          filters:
            - name: dgp.filter.httpconnectionmanager
              config:
                route_config:
                  routes:
                    - match:
                        prefix: "/user"
                      route:
                        cluster: "user"
                        cluster_not_found_response_code: 505
                http_filters:
                  - name: dgp.filter.http.httpproxy
                    config:
                  - name: dgp.filter.http.response
                    config:
  clusters:
    - name: "user"
      lb_policy: "lb"
      endpoints:
        - id: 1
          socket_address:
            address: 127.0.0.1
            port: 1314

More detail will be found in pkg/model/bootstrap.go

static_resources

The static_resources are used to specify unchanged config, meanwhile the dynamic_resources are used for dynamic config. The dynamic_resource feature is still in developing now.

There are four import abstraction in static_resources:

• listener
• filter
• route
• cluster

listener

Listener provides external network server function which support many network protocol, such as http, http2 or tcp.

User can set the protocol and host to allow pixiu listen to it.

When listener receives request from client, it will process it and pass it to the filter.

filter

Filter provides request handle abstraction. You can combine many filters together into filter-chain.

When filter receives request from the listener, it will handle it orderly at its pre or post phase.

Because pixiu wants offer network protocol transform function, so the filter contains the network filter, such as the http filter.

The request processing order is as follows.

client -> listner -> network filter such as httpconnectionmanager -> http filter chain

network filter

Pixiu supports http protocol only, such as dgp.filter.httpconnectionmanager in the above config.

http filter

There also are many protocol-specific filters such as http-to-grpc/http-to-dubbo etc, such as dgp.filter.http.httpproxy in the above config.

There are many build-in filters such as cors/metric/ratelimit/timeout, such as dgp.filter.http.response in the above config.

route

After filter handled the request, pixiu will forward the request to upstream server by route. The route provider forward rules such as path/method/header matches

routes:
- match:
    prefix: "/user"
  route:
    cluster: "user"
    cluster_not_found_response_code: 505

cluster

The cluster represents the same service instance cluster which specify upstream server info.

clusters:
- name: "user"
  lb_policy: "lb"
  endpoints:
    - id: 1
      socket_address:
        address: 127.0.0.1
        port: 1314

Adapter

The adapter communicates with service-registry such as zk/nacos to fetch service instance info and also produces the route and cluster config.

There are two adapters in pkg/adapter.