# FastProxy Configuration Options: A Complete Guide to Client and Server Settings

> Explore FastProxy configuration options for client and server settings. Understand YAML mappings to Go interfaces for efficient proxy management. Get the complete guide.

- Repository: [Kingson4Wu/fast_proxy](https://github.com/kingson4wu/fast_proxy)
- Tags: deep-dive
- Published: 2026-03-05

---

**FastProxy supports two operational modes—in-proxy (client) and out-proxy (server)—with configuration options defined in YAML files that map to Go interfaces in `common/config`, `inproxy/inconfig`, and `outproxy/outconfig` packages.**

FastProxy is a high-performance proxy solution developed in the `kingson4wu/fast_proxy` repository that enables secure, encrypted communication between distributed services. Understanding the available FastProxy configuration options is essential for deploying the in-proxy client mode and out-proxy server mode effectively. This guide details every configurable field, its purpose, and the specific source files where these settings are defined.

## Common Core Configuration Options

These options are defined in [`common/config/config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/common/config/config.go) and are available to both in-proxy and out-proxy modes.

| Option | Type | Description |
|--------|------|-------------|
| `EncryptKeyName` | `string` | Name of the encryption key to use (`encrypt.key.name`). |
| `SignKeyName` | `string` | Name of the signing key (`sign.key.name`). |
| `EncryptEnable` | `bool` | Toggle request/response encryption. |
| `SignEnable` | `bool` | Toggle request/response signing. |
| `CompressEnable` | `bool` | Enable payload compression. |
| `CompressAlgorithm` | `int32` | Compression algorithm identifier (`compress.algorithm`). |
| `ServerName` | `string` | Logical name of the service host. |
| `ServerPort` | `int` | Port on which the service listens. |
| `ServiceRpcHeaderName` | `string` | Header name that carries the target service name (`rpc.serviceHeaderName`). |
| `HttpClientMaxIdleConns` | `int` | Maximum idle HTTP client connections. |
| `HttpClientMaxIdleConnsPerHost` | `int` | Maximum idle connections per host. |
| `FastHttpEnable` | `bool` | Enable the `fasthttp` server implementation. |

### Security and Encryption Settings

The `EncryptKeyName`, `SignKeyName`, `EncryptEnable`, and `SignEnable` fields control the cryptographic layer. When enabled, FastProxy uses the specified key names to look up actual secret values in `encryptKeyConfig` and `signKeyConfig` maps defined in your YAML file.

### Network and HTTP Client Settings

`HttpClientMaxIdleConns` and `HttpClientMaxIdleConnsPerHost` tune the connection pool for outbound requests. Setting `FastHttpEnable` to `true` switches the underlying server implementation from standard `net/http` to `valyala/fasthttp` for better performance under high concurrency.

### Service-Level Configuration

The `ServiceConfig` struct groups per-service toggles including `EncryptEnable`, `SignEnable`, `CompressEnable`, and `CompressAlgorithm`. `ServiceTimeoutConfig` allows setting timeout values in milliseconds for specific service calls, ensuring granular control over service-level behavior.

## In-Proxy (Client) Configuration Options

Implemented in `inproxy/inconfig`, with the interface declared in [`config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/config.go) and YAML loading logic in [`yaml_config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/yaml_config.go). The in-proxy mode acts as the client-side component that forwards requests to the out-proxy server.

| Setting (YAML key) | Type | Meaning |
|--------------------|------|---------|
| `application.name` | `string` | Logical name of the in-proxy instance. |
| `application.port` | `int` | Port on which the in-proxy HTTP server runs. |
| `application.contextPath` | `string` | Base path for the in-proxy API (e.g. `/inProxy`). |
| `rpc.serviceHeaderName` | `string` | Header that carries the downstream service name. |
| `proxy.forwardAddress` | `string` | **(Out-proxy) URL to which the in-proxy forwards traffic.** |
| `serviceConfig.<service>` | object | Per-service toggles (`encryptEnable`, `signEnable`, `compressEnable`) and key names. |
| `signKeyConfig.<keyName>` | `string` | Mapping of signing key names to secret values. |
| `encryptKeyConfig.<keyName>` | `string` | Mapping of encryption key names to secret strings. |
| `serviceCallTypeConfig.<service>.<uri>.callType` | `int` | Call-type flag (e.g., `1` for async). |
| `serviceCallTypeConfig.<service>.<uri>.qps` | `int` | QPS limit for the specific endpoint. |
| `httpClient.MaxIdleConns` | `int` | Overrides the common HTTP client idle-conn limit. |
| `httpClient.MaxIdleConnsPerHost` | `int` | Overrides per-host idle-conn limit. |
| `fastHttp.enable` | `bool` | Use the `fasthttp` implementation for the in-proxy server. |

### Application Settings

The `application` block defines the runtime identity of the in-proxy instance, including its `name`, `port`, and `contextPath`. These values determine how the client-side proxy exposes its HTTP interface and handles incoming requests before forwarding them to the out-proxy.

### Service Routing and Call Types

The `serviceCallTypeConfig` section enables granular control over individual endpoints. You can specify `callType` flags (such as `1` for asynchronous processing) and apply `qps` rate limits to specific service URIs, preventing downstream overload.

### Accessing In-Proxy Configuration in Code

To load and access configuration values programmatically in the in-proxy mode:

```go
import "github.com/Kingson4wu/fast_proxy/inproxy/inconfig"

// Load a YAML file (bytes) into the config implementation
cfg := inconfig.LoadYamlConfig(yamlBytes)

// Register the config globally
inconfig.Read(cfg)

// Retrieve configuration values
ctxPath := inconfig.Get().ServerContextPath()
callType := inconfig.Get().GetCallTypeConfigByName("song_service", "/token_service/api/service")
qps := inconfig.Get().ServiceQps("song_service", "/token_service/api/service")
hasPrivilege := inconfig.Get().ContainsCallPrivilege("song_service", "/token_service/api/service")

```

## Out-Proxy (Server) Configuration Options

Implemented in `outproxy/outconfig`, with the interface declared in [`config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/config.go) and YAML loading logic in [`yaml_config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/yaml_config.go). The out-proxy acts as the server-side component that receives forwarded requests and routes them to upstream services.

| Setting (YAML key) | Type | Meaning |
|--------------------|------|---------|
| `proxy.forwardAddress` | `string` | Destination address for reverse-proxy forwarding (used by out-proxy to send traffic to the real upstream). |
| `application.name` | `string` | Logical name of the out-proxy instance. |
| `application.port` | `int` | Port on which the out-proxy server listens. |
| `application.contextPath` | `string` | Base context path for the out-proxy API (e.g., `/outProxy`). |
| `rpc.serviceHeaderName` | `string` | Header name that carries the downstream service identifier. |
| `serviceConfig.<service>` | object | Same per-service toggles & key names as in in-proxy. |
| `signKeyConfig` / `encryptKeyConfig` | map | Same key-name → secret mappings as in in-proxy. |
| `httpClient.MaxIdleConns` / `MaxIdleConnsPerHost` | `int` | HTTP client connection pool settings for outbound calls. |
| `fastHttp.enable` | `bool` | Switch to the `fasthttp` server for the out-proxy. |

### Reverse Proxy Settings

The `proxy.forwardAddress` field is specific to the out-proxy mode. It defines the upstream URL where the server-side proxy forwards incoming requests after processing security headers, decryption, and decompression.

### Accessing Out-Proxy Configuration in Code

To load and access configuration values programmatically in the out-proxy mode:

```go
import "github.com/Kingson4wu/fast_proxy/outproxy/outconfig"

cfg := outconfig.LoadYamlConfig(yamlBytes)
outconfig.Read(cfg)

forward := outconfig.Get().ForwardAddress()

```

## Complete Configuration Example

Below is a minimal but complete YAML configuration that works for both modes, combining common core settings with mode-specific fields:

```yaml

# Shared application info

application:
  name: my_proxy
  port: 8080
  contextPath: /proxy

# RPC header used to convey service name

rpc:
  serviceHeaderName: C_ServiceName

# Out-proxy forwarding target

proxy:
  forwardAddress: http://127.0.0.1:9833/inProxy

# Service-level encryption / signing options

serviceConfig:
  song_service:
    encryptKeyName: encrypt.key.room.v2
    signKeyName: sign.key.room.v1
    encryptEnable: true
    signEnable: true
    compressEnable: true

# Key/value mappings

signKeyConfig:
  sign.key.room.v1: abcd
  sign.key.room.v2: efgh

encryptKeyConfig:
  encrypt.key.room.v1: ABCDABCDABCDABCDW
  encrypt.key.room.v2: WXYZWXYZWXYZWXYZ

# Call-type & QPS limits per endpoint

serviceCallTypeConfig:
  song_service:
    /token_service/api/service:
      callType: 1
      qps: 10

# HTTP client pool tuning

httpClient:
  MaxIdleConns: 5000
  MaxIdleConnsPerHost: 3000

# Fast-HTTP toggle

fastHttp:
  enable: true

```

All keys correspond directly to the structs and interfaces described in the source files.

## Summary

- **FastProxy configuration options** are centralized in [`common/config/config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/common/config/config.go) for shared settings, while mode-specific logic resides in `inproxy/inconfig` and `outproxy/outconfig`.
- Both in-proxy and out-proxy support encryption, signing, and compression through YAML keys like `encryptEnable`, `signKeyConfig`, and `compressAlgorithm`.
- In-proxy adds client-specific routing controls including `serviceCallTypeConfig` for QPS limits and asynchronous call types.
- Out-proxy adds `proxy.forwardAddress` to define upstream routing targets for reverse proxy operations.
- Configuration is loaded via `LoadYamlConfig()` and registered globally using `Read()`, enabling runtime access through `Get()` methods in both modes.

## Frequently Asked Questions

### How do I configure encryption keys in FastProxy?

Define the key names in the `serviceConfig.<service>.encryptKeyName` field, then map those names to actual secret values in the top-level `encryptKeyConfig` section of your YAML file. The in-proxy and out-proxy both use these mappings to perform encryption and decryption operations.

### What is the difference between in-proxy and out-proxy configuration?

In-proxy configuration focuses on client-side concerns such as `application.port`, `application.contextPath`, and `serviceCallTypeConfig` for routing outbound requests. Out-proxy configuration centers on server-side reverse proxy behavior, primarily using `proxy.forwardAddress` to determine where to send traffic after processing security headers.

### How do I enable fasthttp instead of standard net/http?

Set `fastHttp.enable: true` in your YAML configuration file. This toggle, defined in the common core options, switches both in-proxy and out-proxy servers from the standard library's `net/http` to the high-performance `valyala/fasthttp` implementation.

### Where are configuration files loaded in the FastProxy codebase?

YAML configuration is loaded through `LoadYamlConfig()` functions found in [`inproxy/inconfig/yaml_config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/inproxy/inconfig/yaml_config.go) for client mode and [`outproxy/outconfig/yaml_config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/outproxy/outconfig/yaml_config.go) for server mode. These functions parse the YAML into Go structs defined in the respective [`config.go`](https://github.com/kingson4wu/fast_proxy/blob/main/config.go) interface files.