context.Run(func(ctx context.Context) error
   // business logic
   ......


   return nil
}

// Context of service
// Baetyl runtime context
type Context interface {
   // NodeName returns node name from data.
   NodeName() string
   // AppName returns app name from data.
   AppName() string
   // AppVersion returns application version from data.
   AppVersion() string
   // ServiceName returns service name from data.
   ServiceName() string
   // ConfFile returns config file from data.
   ConfFile() string

   // SystemConfig returns the config of baetyl system from data.
   SystemConfig() *SystemConfig

   // Log returns logger interface.
   Log() *log.Logger

   // Wait waits until exit, receiving SIGTERM and SIGINT signals.
   Wait()
   // WaitChan returns wait channel.
   WaitChan() <-chan os.Signal

   // Load returns the value stored in the map for a key, or nil if no value is present.
   // The ok result indicates whether value was found in the map.
   Load(key interface{}) (value interface{}, ok bool)
   // Store sets the value for a key.
   Store(key, value interface{})
   // LoadOrStore returns the existing value for the key if present.
   // Otherwise, it stores and returns the given value.
   // The loaded result is true if the value was loaded, false if stored.
   LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)
   // Delete deletes the value for a key.
   Delete(key interface{})

   // CheckSystemCert checks system certificate, if certificate is not found or invalid, returns an error.
   CheckSystemCert() error
   // LoadCustomConfig loads custom config.
   // If 'files' is empty, will load config from default path,
   // else the first file path will be used to load config from.
   LoadCustomConfig(cfg interface{}, files ...string) error
   // NewFunctionHttpClient creates a new function http client.
   NewFunctionHttpClient() (*http.Client, error)
   // NewSystemBrokerClientConfig creates the system config of broker
   NewSystemBrokerClientConfig() (mqtt.ClientConfig, error)
   // NewBrokerClient creates a new broker client.
   NewBrokerClient(mqtt.ClientConfig) (*mqtt.Client, error)
   // NewSystemBrokerClient creates a new system broker client.
   NewSystemBrokerClient([]mqtt.QOSTopic) (*mqtt.Client, error)
}

// Config: function 
type Config struct {
	Server http.ServerConfig `yaml:"server" json:"server"`
	Client ClientConfig      `yaml:"client" json:"client"`
}

type ClientConfig struct {
	Grpc GrpcConfig `yaml:"grpc" json:"grpc"`
}

type GrpcConfig struct {
	Port    int           `yaml:"port" json:"port" default:"80"`
	Timeout time.Duration `yaml:"timeout" json:"timeout" default:"5m"`
	Retries int           `yaml:"retries" json:"retries" default:"3"`
}



// program entry
func main() {
    // start service through the context of baetyl-go 
	context.Run(func(ctx context.Context) error {
        // Check if system certificate exists
		if err := ctx.CheckSystemCert(); err != nil {
			return err
		}

		var cfg function.Config
        // load custom config 
		err := ctx.LoadCustomConfig(&cfg)
		if err != nil {
			return errors.Trace(err)
		}

        // Create a parser to get the running mode of the current application through context.RunMode() 
		resolver, err := resolve.New(context.RunMode(), ctx)
		if err != nil {
			return errors.Trace(err)
		}
		defer resolver.Close()

        // create and start function http service
		api, err := function.NewAPI(cfg, ctx, resolver)
		if err != nil {
			return errors.Trace(err)
		}
		defer api.Close()


        // wait to exit, listening SIGTERM and SIGINI signal
		ctx.Wait()
		return nil
	})
}

// HostPathLib return HostPathLib
func HostPathLib() (string, error)
// RunMode return run mode of edge.
func RunMode() string
// EdgeNamespace return namespace of edge.
func EdgeNamespace() string
// EdgeSystemNamespace return system namespace of edge.
func EdgeSystemNamespace() string
// BrokerPort return broker port.
func BrokerPort() string
// FunctionPort return http port of function.
func FunctionHttpPort() string
// BrokerHost return broker host.
func BrokerHost() string
// FunctionHost return function host.
func FunctionHost() string

// return platform info
// specs.Platform{
//    OS:           runtime.GOOS,
//    Architecture: runtime.GOARCH,
//    // The Variant field will be empty if arch != ARM.
//    Variant: cpuVariant,
// }
func Platform() PlatformInfo
// Returns a string of platform information in the following format
// "%s-%s-%s", pl.OS, pl.Architecture, pl.Variant
func PlatformString() string

// NewClient creates a new http client
func NewClient(ops *ClientOptions) *Client


// Call calls the function via HTTP POST
func (c *Client) Call(function string, payload []byte) ([]byte, error)
// PostJSON post data with json content type
func (c *Client) PostJSON(url string, payload []byte, headers ...map[string]string)
// GetJSON get data with json content type
func (c *Client) GetJSON(url string, headers ...map[string]string) ([]byte, error)
func (c *Client) GetURL(url string, header ...map[string]string) 
func (c *Client) PostURL(url string, body io.Reader, header ...map[string]string)
func (c *Client) SendUrl(method, url string, body io.Reader, header ...map[string]string)

// NewServer new server
func NewServer(cfg ServerConfig, handler fasthttp.RequestHandler) *Server


func (s *Server) Start()
func (s *Server) Close()