【Envoy-04】Envoy xDS Dynamic Configuration and Control Plane Interactions

# https://github.com/solo-io/hoot/blob/master/04-xds/xds.yaml
node:
  id: node-1
  cluster: edge-gateway

admin:
  access_log_path: /dev/stdout
  address:
    socket_address: { address: 127.0.0.1, port_value: 9901 }

layered_runtime:
  # use runtime to limit number of connections to prevent file descriptor exhaustion
  layers:
    - name: static_layer_0
      static_layer:
        overload:
          global_downstream_max_connections: 100

dynamic_resources:
  ads_config:
    # allows limiting the rate of discovery requests.
    # for edge cases with very frequent requests or due to a bug.
    rate_limit_settings:
      max_tokens: 10
      fill_rate: 3
    # we use v3 xDS framing
    transport_api_version: V3
    # over gRPC
    api_type: GRPC
    grpc_services:
      - envoy_grpc:
          cluster_name: xds_cluster
  # Use ADS for LDS and CDS; request V3 clusters and listeners.
  lds_config: {ads: {}, resource_api_version: V3}
  cds_config: {ads: {}, resource_api_version: V3}

static_resources:
  clusters:
  - name: xds_cluster
    connect_timeout: 0.25s
    type: STATIC
    lb_policy: ROUND_ROBIN
    # as we are using gRPC xDS we need to set the cluster to use http2
    http2_protocol_options: {}
    upstream_connection_options:
      # important:
      # configure a TCP keep-alive to detect and reconnect to the admin
      # server in the event of a TCP socket half open connection
      # the default values are very conservative, so you will want to tune them.
      tcp_keepalive: {}
    load_assignment:
      cluster_name: xds_cluster
      endpoints:
      - lb_endpoints:
        - endpoint:
            address:
              socket_address:
                address: 127.0.0.1
                port_value: 9977

const (
    // don't use dots in resource name
	ClusterName1  = "cluster_a"
    ClusterName2  = "cluster_b"
    RouteName     = "local_route"
    ListenerName  = "listener_0"
    ListenerPort  = 10000
    UpstreamHost  = "127.0.0.1"
    UpstreamPort1 = 8082
    UpstreamPort2 = 8083

    xdsPort                  = 9977
    grpcMaxConcurrentStreams = 1000000
)
func makeRoute(routeName string, weight uint32, clusterName1, clusterName2 string) *route.RouteConfiguration {
	routeConfiguration := &route.RouteConfiguration{
		Name: routeName,
		VirtualHosts: []*route.VirtualHost{{
			Name:    "local_service",
			Domains: []string{"*"},
		}},
	}
	switch weight {
	case 0:
		// update route to clusterName1
		routeConfiguration.VirtualHosts[0].Routes = []*route.Route{{
			Match: &route.RouteMatch{
				PathSpecifier: &route.RouteMatch_Prefix{
					Prefix: "/",
				},
			},
			Action: &route.Route_Route{
				Route: &route.RouteAction{
					ClusterSpecifier: &route.RouteAction_Cluster{
						Cluster: clusterName1,
					},
					HostRewriteSpecifier: &route.RouteAction_HostRewriteLiteral{
						HostRewriteLiteral: UpstreamHost,
					},
				},
			},
		}}

	case 100:
	    // update route to clusterName2
		routeConfiguration.VirtualHosts[0].Routes = []*route.Route{{
			Match: &route.RouteMatch{
				PathSpecifier: &route.RouteMatch_Prefix{
					Prefix: "/",
				},
			},
			Action: &route.Route_Route{
				Route: &route.RouteAction{
					ClusterSpecifier: &route.RouteAction_Cluster{
						Cluster: clusterName2,
					},
					HostRewriteSpecifier: &route.RouteAction_HostRewriteLiteral{
						HostRewriteLiteral: UpstreamHost,
					},
				},
			},
		}}
		// canary-roll out: update route based on percentage of weight in each cluster
	default:
		routeConfiguration.VirtualHosts[0].Routes = []*route.Route{{
			Match: &route.RouteMatch{
				PathSpecifier: &route.RouteMatch_Prefix{
					Prefix: "/",
				},
			},
			Action: &route.Route_Route{
				Route: &route.RouteAction{
					ClusterSpecifier: &route.RouteAction_WeightedClusters{
						WeightedClusters: &route.WeightedCluster{
							TotalWeight: &wrapperspb.UInt32Value{
								Value: 100,
							},
							Clusters: []*route.WeightedCluster_ClusterWeight{
								{
									Name: clusterName1,
									Weight: &wrapperspb.UInt32Value{
										Value: 100 - weight,
									},
								},
								{
									Name: clusterName2,
									Weight: &wrapperspb.UInt32Value{
										Value: weight,
									},
								},
							},
						},
					},
					HostRewriteSpecifier: &route.RouteAction_HostRewriteLiteral{
						HostRewriteLiteral: UpstreamHost,
					},
				},
			},
		}}

	}
	return routeConfiguration
}

/// https://github.com/solo-io/hoot/blob/master/04-xds/server.go
func redServer(rw http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(rw, "red")
}
func blueServer(rw http.ResponseWriter, r *http.Request) {
    rw.WriteHeader(http.StatusAccepted)
    fmt.Fprintln(rw, "blue")
}

func main() {
	l, err := net.Listen("tcp", ":8082")
	if err != nil {
		log.Fatal("listen error:", err)
	}
	l2, err := net.Listen("tcp", ":8083")
	if err != nil {
		log.Fatal("listen error:", err)
	}
	go http.Serve(l, http.HandlerFunc(redServer))
	go http.Serve(l2, http.HandlerFunc(blueServer))

	select {}
}

# running the xds server as a control plane
go run xds.go

# running a application server with 2 cluster endpoints for route switching
go run server.go
# running a envoy server with xds.yaml configuration
envoy -c xds.yaml

# request the envoy port 10000, it will redirect to the application server
curl localhost:10000
# 100% returns red with 200 status code because all the traffic go to cluster-a
red

Enter weight for cluster-b: 5
setting weight to 5
publishing version: snapshow-2

# request the envoy port 10000, it will redirect to the application server
curl localhost:10000
# 95% chance returns red with 200 status code
red
# 5% chance returns blue with 202 status code
blue