feat: Crafting Load Balancer Proxy

Makefile

@@ -0,0 +1,28 @@
+ENDPOINT=http://192.168.137.1:7860
+
+start: go run main.go
+
+haproxy-test:
+	haproxy -f ./haproxy/haproxy.cfg
+
+nginx-test:
+	nginx -c nginx.conf
+
+traefik-test:
+	traefik \
+		--configFile=./traefik/traefik.yaml \
+		--entryPoints.web.address=":7860" \
+		--entryPoints.websecure.address=":443" \
+		--entryPoints.web.http.redirections.entryPoint.to=websecure \
+		--entryPoints.web.http.redirections.entryPoint.scheme=https \
+		--api.dashboard=true \
+		--api.insecure=false
+
+crypto-list-test:
+	curl -X GET $(ENDPOINT)/crypto/lists
+
+crypto-prediction-test:
+	curl -X POST $(ENDPOINT)/crypto/prediction \
+		-H "Content-Type: application/json" \
+		-d "{\"days\": 2, \"currency\": \"BTC-USD\"}"
+	

go.mod

@@ -0,0 +1,20 @@
+module tebakaja_lb_proxy
+
+go 1.20
+
+require (
+	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/gofiber/fiber/v2 v2.52.5 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/philhofer/fwd v1.1.2 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/tinylib/msgp v1.1.8 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasthttp v1.55.0 // indirect
+	github.com/valyala/tcplisten v1.0.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
+)

go.sum

@@ -0,0 +1,62 @@
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/gofiber/fiber/v2 v2.52.5 h1:tWoP1MJQjGEe4GB5TUGOi7P2E0ZMMRx5ZTG4rT+yGMo=
+github.com/gofiber/fiber/v2 v2.52.5/go.mod h1:KEOE+cXMhXG0zHc9d8+E38hoX+ZN7bhOtgeF2oT6jrQ=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw=
+github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/tinylib/msgp v1.1.8 h1:FCXC1xanKO4I8plpHGH2P7koL/RzZs12l/+r7vakfm0=
+github.com/tinylib/msgp v1.1.8/go.mod h1:qkpG+2ldGg4xRFmx+jfTvZPxfGFhi64BcnL9vkCm/Tw=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.55.0 h1:Zkefzgt6a7+bVKHnu/YaYSOPfNYNisSVBo/unVCf8k8=
+github.com/valyala/fasthttp v1.55.0/go.mod h1:NkY9JtkrpPKmgwV3HTaS2HWaJss9RSIsRVfcxxoHiOM=
+github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
+github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.3.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

haproxy/haproxy.cfg

@@ -0,0 +1,61 @@
+global
+    daemon
+    maxconn 1024
+    log /dev/log local0
+    log /dev/log local1 notice
+    stats timeout 30s
+
+    ssl-default-bind-ciphers ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!MD5:!DSS
+
+defaults
+    log global
+    mode http
+    option httplog
+    option dontlognull
+    retries 3
+    option redispatch
+    timeout http-request 10s
+    timeout queue 10s
+    timeout connect 10s
+    timeout client 10s
+    timeout server 10s
+    timeout check 10s
+
+frontend http_front
+    bind *:80
+    bind :::80
+    mode http
+
+    stick-table type ip size 100k expire 30s store http_req_rate(10s)
+    http-request track-sc0 src
+    http-request deny deny_status 429 if { sc_http_req_rate(0) gt 100 }
+
+    acl is_websocket hdr(Upgrade) -i websocket
+    acl is_websocket hdr_beg(Host) -i ws
+
+    use_backend websocket_chatting_back if is_websocket
+    default_backend websocket_chatting_back
+
+frontend https_front
+    bind *:443 ssl crt F:\command\haproxy\certificates.pem
+    bind :::443 ssl crt F:\command\haproxy\certificates.pem
+    mode http
+
+    acl is_websocket hdr(Upgrade) -i websocket
+    acl is_websocket hdr_beg(Host) -i ws
+
+    stick-table type ip size 100k expire 30s store http_req_rate(10s)
+    http-request track-sc0 src
+    http-request deny deny_status 429 if { sc_http_req_rate(0) gt 100 }
+
+    use_backend websocket_chatting_back if is_websocket
+    default_backend websocket_chatting_back
+
+backend websocket_chatting_back
+    mode http
+    timeout queue 10s
+    balance roundrobin
+    option forwardfor
+    http-request set-header X-Forwarded-Port %[dst_port]
+    http-request add-header X-Forwarded-Proto https if { ssl_fc }
+    server websocket_svc_1 qywok-cryptocurrency-prediction.hf.space:443/crypto/lists ssl verify required check

main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	
+	"github.com/gofiber/fiber/v2"
+
+	proxy "tebakaja_lb_proxy/proxy"
+	crypto_proxy "tebakaja_lb_proxy/proxy/crypto"
+)
+
+func main() {
+	app := fiber.New()
+
+	app.Use(proxy.LoggingMiddleware)
+	app.Use(proxy.RateLimiter())
+
+	cryptoGroup := app.Group("/crypto")
+	cryptoGroup.Get("/lists", crypto_proxy.CryptoListsHandler(&crypto_proxy.CryptoServiceImpl{}))
+	cryptoGroup.Post("/prediction", crypto_proxy.CryptoPredictionHandler(&crypto_proxy.CryptoServiceImpl{}))
+
+	port := 7860
+	log.Fatal(app.Listen(fmt.Sprintf("0.0.0.0:%d", port)))
+}

proxy/crypto/constants.go

@@ -0,0 +1,3 @@
+package crypto
+
+const CRYPTO_ENDPOINT = "https://qywok-cryptocurrency-prediction.hf.space/crypto"

proxy/crypto/interfaces.go

@@ -0,0 +1,10 @@
+package crypto
+
+import "context"
+
+type CryptoService interface {
+	CryptoListsService(ctx context.Context) (ApiResponse, error)
+	CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error)
+}
+
+type CryptoServiceImpl struct{}

proxy/crypto/list_handler.go

@@ -0,0 +1,60 @@
+package crypto
+
+import (
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Handler ---
+ */
+func CryptoListsHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			apiResponse, err := service.CryptoListsService(ctx)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+		case apiResponse, ok := <-ch:
+			if !ok {
+				return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+					"error": "Failed to get a response from the server",
+				})
+			}
+			return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+		case <-ctx.Done():
+			log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+			return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+				"error": "Request timeout",
+			})
+		}
+	}
+}

proxy/crypto/list_service.go

@@ -0,0 +1,49 @@
+package crypto
+
+import (
+	"fmt"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Service ---
+ */
+func (s *CryptoServiceImpl) CryptoListsService(ctx context.Context) (ApiResponse, error) {
+	endpoint := fmt.Sprintf("%s/lists", CRYPTO_ENDPOINT)
+	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse ApiResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return apiResponse, nil
+}

proxy/crypto/prediction_handler.go

@@ -0,0 +1,73 @@
+package crypto
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Handler ---
+ */
+func CryptoPredictionHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			var predictionReq PredictionRequest
+			if err := c.BodyParser(&predictionReq); err != nil {
+				log.Printf("[%s] Failed to parse request body: %v",
+					time.Now().Format("2006-01-02 15:04:05"), err)
+
+				ch <- ApiResponse{
+					Message:    fmt.Sprintf("Failed to parse request body: %v", err),
+					StatusCode: http.StatusBadRequest,
+				}
+				return
+			}
+
+			apiResponse, err := service.CryptoPredictionService(ctx, predictionReq)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+		case apiResponse, ok := <-ch:
+			if !ok {
+				return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+					"error": "Failed to get a response from the server",
+				})
+			}
+			return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+		case <-ctx.Done():
+			log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+			return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+				"error": "Request timeout",
+			})
+		}
+	}
+}

proxy/crypto/prediction_service.go

@@ -0,0 +1,63 @@
+package crypto
+
+import (
+	"fmt"
+	"bytes"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Service ---
+ */
+func (s *CryptoServiceImpl) CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error) {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to marshal request body: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	endpoint := fmt.Sprintf("%s/prediction", CRYPTO_ENDPOINT)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse PredictionResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return ApiResponse{
+		Message:    apiResponse.Message,
+		StatusCode: apiResponse.StatusCode,
+		Data:       apiResponse.Data,
+	}, nil
+}

proxy/crypto/structs.go

@@ -0,0 +1,31 @@
+package crypto
+
+type ApiResponse struct {
+	Message    string      `json:"message"`
+	StatusCode int         `json:"status_code"`
+	Data       interface{} `json:"data"`
+}
+
+type PredictionRequest struct {
+	Days     int    `json:"days"`
+	Currency string `json:"currency"`
+}
+
+type PredictionResponse struct {
+	Message    string `json:"message"`
+	StatusCode int    `json:"status_code"`
+
+	Data       struct {
+		Currency    string `json:"currency"`
+		Predictions struct {
+			Actuals    []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"actuals"`
+			Predictions []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"predictions"`
+		} `json:"predictions"`
+	} `json:"data"`
+}

proxy/loadbalancers.go

@@ -0,0 +1 @@
+package proxy

proxy/middlewares.go

@@ -0,0 +1,34 @@
+package proxy
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/limiter"
+)
+
+// Middleware untuk logging setiap request
+func LoggingMiddleware(c *fiber.Ctx) error {
+	start := time.Now()
+	err := c.Next()
+	log.Printf("[%s] %s %s - %d %s in %v", time.Now().Format("2006-01-02 15:04:05"), c.Method(), c.Path(), c.Response().StatusCode(), http.StatusText(c.Response().StatusCode()), time.Since(start))
+	return err
+}
+
+// Middleware rate limiter: 200 requests per menit per IP
+func RateLimiter() func(*fiber.Ctx) error {
+	return limiter.New(limiter.Config{
+		Max:        200,
+		Expiration: 1 * time.Minute,
+		KeyGenerator: func(c *fiber.Ctx) string {
+			return c.IP()
+		},
+		LimitReached: func(c *fiber.Ctx) error {
+			return c.Status(http.StatusTooManyRequests).JSON(fiber.Map{
+				"error": "Rate limit exceeded",
+			})
+		},
+	})
+}

proxy/national_currency/constants.go

@@ -0,0 +1,3 @@
+package national_currency
+
+const CRYPTO_ENDPOINT = "https://qywok-cryptocurrency-prediction.hf.space/crypto"

proxy/national_currency/interfaces.go

@@ -0,0 +1,10 @@
+package national_currency
+
+import "context"
+
+type CryptoService interface {
+	CryptoListsService(ctx context.Context) (ApiResponse, error)
+	CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error)
+}
+
+type CryptoServiceImpl struct{}

proxy/national_currency/list_handler.go

@@ -0,0 +1,60 @@
+package national_currency
+
+import (
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Handler ---
+ */
+func CryptoListsHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			apiResponse, err := service.CryptoListsService(ctx)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+			case apiResponse, ok := <-ch:
+				if !ok {
+					return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+						"error": "Failed to get a response from the server",
+					})
+				}
+				return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+			case <-ctx.Done():
+				log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+				return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+					"error": "Request timeout",
+				})
+		}
+	}
+}

proxy/national_currency/list_service.go

@@ -0,0 +1,49 @@
+package national_currency
+
+import (
+	"fmt"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Service ---
+ */
+func (s *CryptoServiceImpl) CryptoListsService(ctx context.Context) (ApiResponse, error) {
+	endpoint := fmt.Sprintf("%s/lists", CRYPTO_ENDPOINT)
+	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse ApiResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return apiResponse, nil
+}

proxy/national_currency/prediction_handler.go

@@ -0,0 +1,73 @@
+package national_currency
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Handler ---
+ */
+func CryptoPredictionHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			var predictionReq PredictionRequest
+			if err := c.BodyParser(&predictionReq); err != nil {
+				log.Printf("[%s] Failed to parse request body: %v",
+					time.Now().Format("2006-01-02 15:04:05"), err)
+
+				ch <- ApiResponse{
+					Message:    fmt.Sprintf("Failed to parse request body: %v", err),
+					StatusCode: http.StatusBadRequest,
+				}
+				return
+			}
+
+			apiResponse, err := service.CryptoPredictionService(ctx, predictionReq)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+		case apiResponse, ok := <-ch:
+			if !ok {
+				return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+					"error": "Failed to get a response from the server",
+				})
+			}
+			return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+		case <-ctx.Done():
+			log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+			return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+				"error": "Request timeout",
+			})
+		}
+	}
+}

proxy/national_currency/prediction_service.go

@@ -0,0 +1,63 @@
+package national_currency
+
+import (
+	"fmt"
+	"bytes"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Service ---
+ */
+func (s *CryptoServiceImpl) CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error) {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to marshal request body: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	endpoint := fmt.Sprintf("%s/prediction", CRYPTO_ENDPOINT)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse PredictionResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return ApiResponse{
+		Message:    apiResponse.Message,
+		StatusCode: apiResponse.StatusCode,
+		Data:       apiResponse.Data,
+	}, nil
+}

proxy/national_currency/structs.go

@@ -0,0 +1,31 @@
+package national_currency
+
+type ApiResponse struct {
+	Message    string      `json:"message"`
+	StatusCode int         `json:"status_code"`
+	Data       interface{} `json:"data"`
+}
+
+type PredictionRequest struct {
+	Days     int    `json:"days"`
+	Currency string `json:"currency"`
+}
+
+type PredictionResponse struct {
+	Message    string `json:"message"`
+	StatusCode int    `json:"status_code"`
+
+	Data       struct {
+		Currency    string `json:"currency"`
+		Predictions struct {
+			Actuals    []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"actuals"`
+			Predictions []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"predictions"`
+		} `json:"predictions"`
+	} `json:"data"`
+}

proxy/stock/constants.go

@@ -0,0 +1,3 @@
+package stock
+
+const CRYPTO_ENDPOINT = "https://qywok-cryptocurrency-prediction.hf.space/crypto"

proxy/stock/interfaces.go

@@ -0,0 +1,10 @@
+package stock
+
+import "context"
+
+type CryptoService interface {
+	CryptoListsService(ctx context.Context) (ApiResponse, error)
+	CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error)
+}
+
+type CryptoServiceImpl struct{}

proxy/stock/list_handler.go

@@ -0,0 +1,60 @@
+package stock
+
+import (
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Handler ---
+ */
+func CryptoListsHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			apiResponse, err := service.CryptoListsService(ctx)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+			case apiResponse, ok := <-ch:
+				if !ok {
+					return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+						"error": "Failed to get a response from the server",
+					})
+				}
+				return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+			case <-ctx.Done():
+				log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+				return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+					"error": "Request timeout",
+				})
+		}
+	}
+}

proxy/stock/list_service.go

@@ -0,0 +1,49 @@
+package stock
+
+import (
+	"fmt"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ *  --- Cryptocurrency Prediction Model Lists Service ---
+ */
+func (s *CryptoServiceImpl) CryptoListsService(ctx context.Context) (ApiResponse, error) {
+	endpoint := fmt.Sprintf("%s/lists", CRYPTO_ENDPOINT)
+	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse ApiResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return apiResponse, nil
+}

proxy/stock/prediction_handler.go

@@ -0,0 +1,73 @@
+package stock
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+	"context"
+	"net/http"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Handler ---
+ */
+func CryptoPredictionHandler(service CryptoService) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		ctx, cancel := context.WithTimeout(c.Context(), 120*time.Second)
+		defer cancel()
+
+		ch := make(chan ApiResponse, 1)
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			var predictionReq PredictionRequest
+			if err := c.BodyParser(&predictionReq); err != nil {
+				log.Printf("[%s] Failed to parse request body: %v",
+					time.Now().Format("2006-01-02 15:04:05"), err)
+
+				ch <- ApiResponse{
+					Message:    fmt.Sprintf("Failed to parse request body: %v", err),
+					StatusCode: http.StatusBadRequest,
+				}
+				return
+			}
+
+			apiResponse, err := service.CryptoPredictionService(ctx, predictionReq)
+			if err != nil {
+				log.Printf("[%s] %v", time.Now().Format("2006-01-02 15:04:05"), err)
+				ch <- apiResponse
+				return
+			}
+
+			ch <- apiResponse
+		}()
+
+		go func() {
+			wg.Wait()
+			close(ch)
+		}()
+
+		select {
+		case apiResponse, ok := <-ch:
+			if !ok {
+				return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+					"error": "Failed to get a response from the server",
+				})
+			}
+			return c.Status(apiResponse.StatusCode).JSON(apiResponse)
+
+		case <-ctx.Done():
+			log.Printf("[%s] Timeout: %v", time.Now().Format("2006-01-02 15:04:05"), ctx.Err())
+			return c.Status(http.StatusRequestTimeout).JSON(fiber.Map{
+				"error": "Request timeout",
+			})
+		}
+	}
+}

proxy/stock/prediction_service.go

@@ -0,0 +1,63 @@
+package stock
+
+import (
+	"fmt"
+	"bytes"
+	"context"
+	"net/http"
+	"encoding/json"
+)
+
+
+/*
+ * --- Cryptocurrency Prediction Service ---
+ */
+func (s *CryptoServiceImpl) CryptoPredictionService(ctx context.Context, req PredictionRequest) (ApiResponse, error) {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to marshal request body: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	endpoint := fmt.Sprintf("%s/prediction", CRYPTO_ENDPOINT)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to make request: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Request failed: %d", resp.StatusCode),
+			StatusCode: resp.StatusCode,
+		}, fmt.Errorf("request failed: %d", resp.StatusCode)
+	}
+
+	var apiResponse PredictionResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
+		return ApiResponse{
+			Message:    fmt.Sprintf("Failed to parse JSON response: %v", err),
+			StatusCode: http.StatusInternalServerError,
+		}, err
+	}
+
+	return ApiResponse{
+		Message:    apiResponse.Message,
+		StatusCode: apiResponse.StatusCode,
+		Data:       apiResponse.Data,
+	}, nil
+}

proxy/stock/structs.go

@@ -0,0 +1,31 @@
+package stock
+
+type ApiResponse struct {
+	Message    string      `json:"message"`
+	StatusCode int         `json:"status_code"`
+	Data       interface{} `json:"data"`
+}
+
+type PredictionRequest struct {
+	Days     int    `json:"days"`
+	Currency string `json:"currency"`
+}
+
+type PredictionResponse struct {
+	Message    string `json:"message"`
+	StatusCode int    `json:"status_code"`
+
+	Data       struct {
+		Currency    string `json:"currency"`
+		Predictions struct {
+			Actuals    []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"actuals"`
+			Predictions []struct {
+				Date  string  `json:"date"`
+				Price float64 `json:"price"`
+			} `json:"predictions"`
+		} `json:"predictions"`
+	} `json:"data"`
+}

traefik/dynamic.yaml

@@ -0,0 +1,42 @@
+http:
+  middlewares:
+    dashboard-auth:
+      basicAuth:
+        users:
+          # - "admin:$apr1$vO3/IDvg$JrbhU9NSQub83/mQu9/fP1"
+        
+    rate-limit:
+      rateLimit:
+        average: 100
+        burst: 50
+
+  routers:
+    api:
+      rule: "PathPrefix(`/api`)"
+      entryPoints:
+        - "web"
+      middlewares:
+        - "dashboard-auth"
+        - "rate-limit"
+      service: "api@internal"
+
+    dashboard:
+      rule: "PathPrefix(`/dashboard`)"
+      entryPoints:
+        - "web"
+      middlewares:
+        - "dashboard-auth"
+        - "rate-limit"
+      service: "api@internal"
+
+    crypto-lists:
+      rule: "PathPrefix(`/crypto/lists`)"
+      entryPoints:
+        - "websecure"
+      service: "crypto-lists-service"
+
+  services:
+    crypto-lists-service:
+      loadBalancer:
+        servers:
+          - url: "https://qywok-cryptocurrency-prediction.hf.space/crypto/lists" 

traefik/traefik.yaml

@@ -0,0 +1,14 @@
+providers:
+  file:
+    filename: ./traefik/dynamic.yaml
+    watch: true
+
+entryPoints:
+  web:
+    address: ":7860"
+  websecure:
+    address: ":443"
+
+api:
+  dashboard: true
+  insecure: false