feat: funcs as global Go service (sless-funcs-service:v0.1.1)

- services/funcs/main.go: standalone Go HTTP server extracts JWT sub -> SHA256[:8] -> namespace -> calls operator API returns plain text list, sorted active first, /health probe endpoint - services/funcs/Dockerfile: multi-stage Go build -> alpine - deployments/k8s/funcs-service.yaml: Deployment+Service+Ingress in sless ns ingress path /funcs -> sless-funcs-service:8090, reuses sless-operator-tls - examples/POSTGRES/resources.tf: removed funcs_list function+trigger+output Image: naeel/sless-funcs-service:v0.1.1
2026-03-18 15:58:08 +03:00
parent 9bc91841c8
commit e8cd62e171
5 changed files with 398 additions and 44 deletions
@@ -0,0 +1,15 @@
+# 2026-03-18
+# Dockerfile для sless-funcs-service.
+# Многоэтапная сборка: Go → alpine (минимальный образ).
+# Сервис не нуждается во внешних зависимостях — только stdlib.
+
+FROM golang:1.23-alpine AS builder
+WORKDIR /build
+COPY go.mod main.go ./
+RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o funcs-service .
+
+FROM alpine:3.20
+RUN apk add --no-cache ca-certificates
+COPY --from=builder /build/funcs-service /funcs-service
+EXPOSE 8090
+ENTRYPOINT ["/funcs-service"]
@@ -0,0 +1,3 @@
+module sless/funcs-service
+
+go 1.23
@@ -0,0 +1,275 @@
+// 2026-03-18
+// main.go — глобальный HTTP сервис листинга функций пользователя.
+// Развёрнут ОДИН РАЗ в namespace sless; работает для ВСЕХ пользователей.
+// Не связан с terraform — деплоится манифестом deployments/k8s/funcs-service.yaml.
+//
+// Логика:
+//   1. Принимает Authorization: Bearer {jwt} от пользователя
+//   2. Извлекает sub из JWT (без проверки подписи — trusted perimeter за Ingress)
+//   3. Вычисляет namespace = SHA256(sub)[:8] hex (та же логика что в операторе)
+//   4. Вызывает внутренний API оператора: GET /v1/namespaces/{ns}/functions + /triggers
+//   5. Возвращает plain text — человекочитаемый список
+//
+// Env vars:
+//   SLESS_OPERATOR_URL  — URL оператора внутри кластера (default: http://sless-operator.sless.svc.cluster.local:9090)
+//   SLESS_EXTERNAL_URL  — публичный базовый URL для корректных ссылок на функции
+//   SLESS_EXCLUDE       — comma-separated список имён функций, скрытых из листинга
+//   PORT                — порт сервера (default: 8090)
+
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"sort"
+	"strings"
+)
+
+// fnResponse — ответ /v1/namespaces/{ns}/functions (подмножество полей оператора)
+type fnResponse struct {
+	Name        string `json:"name"`
+	Runtime     string `json:"runtime"`
+	Phase       string `json:"phase"`
+	Message     string `json:"message"`
+	CreatedAt   string `json:"created_at"`
+	LastBuiltAt string `json:"last_built_at"`
+}
+
+// trResponse — ответ /v1/namespaces/{ns}/triggers
+type trResponse struct {
+	Name        string `json:"name"`
+	Type        string `json:"type"`
+	FunctionRef string `json:"function"`
+	Schedule    string `json:"schedule"`
+	Enabled     bool   `json:"enabled"`
+	Active      bool   `json:"active"`
+	URL         string `json:"url"`
+}
+
+func main() {
+	operatorURL := strings.TrimRight(env("SLESS_OPERATOR_URL", "http://sless-operator.sless.svc.cluster.local:9090"), "/")
+	externalURL := strings.TrimRight(env("SLESS_EXTERNAL_URL", ""), "/")
+	port := env("PORT", "8090")
+
+	exclude := map[string]bool{}
+	for _, n := range strings.Split(os.Getenv("SLESS_EXCLUDE"), ",") {
+		if n = strings.TrimSpace(n); n != "" {
+			exclude[n] = true
+		}
+	}
+
+	http.HandleFunc("/funcs", handler(operatorURL, externalURL, exclude))
+	// /health — для liveness/readiness probe без Bearer токена
+	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		fmt.Fprintln(w, "ok")
+	})
+
+	log.Printf("sless-funcs-service listening on :%s (operator: %s)", port, operatorURL)
+	log.Fatal(http.ListenAndServe(":"+port, nil))
+}
+
+func handler(operatorURL, externalURL string, exclude map[string]bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/funcs" {
+			http.NotFound(w, r)
+			return
+		}
+
+		token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+		if token == "" {
+			http.Error(w, "Authorization: Bearer <token> required\n", http.StatusUnauthorized)
+			return
+		}
+
+		sub, err := subFromJWT(token)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("invalid token: %s\n", err), http.StatusUnauthorized)
+			return
+		}
+		namespace := namespaceFromSub(sub)
+		authHeader := "Bearer " + token
+
+		fns, err := apiGet[[]fnResponse](operatorURL+"/v1/namespaces/"+namespace+"/functions", authHeader)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("operator error (functions): %s\n", err), http.StatusBadGateway)
+			return
+		}
+		trs, err := apiGet[[]trResponse](operatorURL+"/v1/namespaces/"+namespace+"/triggers", authHeader)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("operator error (triggers): %s\n", err), http.StatusBadGateway)
+			return
+		}
+
+		// Индекс триггеров по имени функции
+		trigIdx := map[string][]trResponse{}
+		for _, tr := range trs {
+			trigIdx[tr.FunctionRef] = append(trigIdx[tr.FunctionRef], tr)
+		}
+
+		// Фильтрация и сортировка: активные вверх, потом по имени
+		type entry struct {
+			fn       fnResponse
+			httpT    []trResponse
+			cronT    []trResponse
+			isActive bool
+		}
+		var items []entry
+		for _, fn := range fns {
+			if exclude[fn.Name] {
+				continue
+			}
+			var httpT, cronT []trResponse
+			isActive := false
+			for _, tr := range trigIdx[fn.Name] {
+				switch tr.Type {
+				case "http":
+					httpT = append(httpT, tr)
+				case "cron":
+					cronT = append(cronT, tr)
+				}
+				if tr.Enabled && tr.Active {
+					isActive = true
+				}
+			}
+			items = append(items, entry{fn, httpT, cronT, isActive})
+		}
+		sort.Slice(items, func(i, j int) bool {
+			if items[i].isActive != items[j].isActive {
+				return items[i].isActive
+			}
+			return items[i].fn.Name < items[j].fn.Name
+		})
+
+		sep := strings.Repeat("─", 52)
+		var sb strings.Builder
+		for _, it := range items {
+			fn := it.fn
+			sb.WriteString(sep + "\n")
+			sb.WriteString("  " + buildComment(fn, it.httpT, it.cronT) + "\n")
+			sb.WriteString(fmt.Sprintf("  name:      %s\n", fn.Name))
+			sb.WriteString(fmt.Sprintf("  runtime:   %s\n", fn.Runtime))
+			sb.WriteString(fmt.Sprintf("  phase:     %s\n", fn.Phase))
+			if it.isActive {
+				sb.WriteString("  active:    да\n")
+			} else {
+				sb.WriteString("  active:    нет\n")
+			}
+			if len(it.httpT) > 0 {
+				url := it.httpT[0].URL
+				if externalURL != "" {
+					url = externalURL + "/fn/" + namespace + "/" + fn.Name
+				}
+				sb.WriteString(fmt.Sprintf("  url:       %s\n", url))
+			}
+			if len(it.cronT) > 0 {
+				sb.WriteString(fmt.Sprintf("  cron:      %s\n", it.cronT[0].Schedule))
+			}
+			if fn.CreatedAt != "" {
+				sb.WriteString(fmt.Sprintf("  created:   %s\n", fn.CreatedAt))
+			}
+			if fn.LastBuiltAt != "" {
+				sb.WriteString(fmt.Sprintf("  built:     %s\n", fn.LastBuiltAt))
+			}
+			if fn.Message != "" {
+				sb.WriteString(fmt.Sprintf("  message:   %s\n", fn.Message))
+			}
+		}
+		sb.WriteString(sep + "\n")
+		sb.WriteString(fmt.Sprintf("  namespace: %s  |  total: %d\n", namespace, len(items)))
+		sb.WriteString(sep + "\n")
+
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		fmt.Fprint(w, sb.String())
+	}
+}
+
+func buildComment(fn fnResponse, httpT, cronT []trResponse) string {
+	if len(httpT) > 0 {
+		active := "активна"
+		if !httpT[0].Active {
+			active = "неактивна"
+		}
+		return fmt.Sprintf("HTTP endpoint (%s) — %s, %s", fn.Runtime, fn.Phase, active)
+	}
+	if len(cronT) > 0 {
+		active := "активна"
+		if !cronT[0].Active {
+			active = "неактивна"
+		}
+		return fmt.Sprintf("Cron '%s' (%s) — %s, %s", cronT[0].Schedule, fn.Runtime, fn.Phase, active)
+	}
+	return fmt.Sprintf("Job/runner без триггера (%s) — %s", fn.Runtime, fn.Phase)
+}
+
+// subFromJWT декодирует JWT payload (без проверки подписи) и возвращает sub.
+// Подпись не проверяется — trusted perimeter: сервис работает за Ingress.
+func subFromJWT(token string) (string, error) {
+	parts := strings.Split(token, ".")
+	if len(parts) != 3 {
+		return "", fmt.Errorf("invalid jwt: expected 3 parts")
+	}
+	// base64url без паддинга — добавляем паддинг стандартно
+	payload := parts[1]
+	switch len(payload) % 4 {
+	case 2:
+		payload += "=="
+	case 3:
+		payload += "="
+	}
+	data, err := base64.URLEncoding.DecodeString(payload)
+	if err != nil {
+		return "", fmt.Errorf("decode payload: %w", err)
+	}
+	var claims map[string]any
+	if err := json.Unmarshal(data, &claims); err != nil {
+		return "", fmt.Errorf("unmarshal claims: %w", err)
+	}
+	sub, ok := claims["sub"].(string)
+	if !ok || sub == "" {
+		return "", fmt.Errorf("missing sub claim")
+	}
+	return sub, nil
+}
+
+// namespaceFromSub — та же логика что в операторе и terraform провайдере.
+// SHA256(sub) → первые 8 байт → hex → "sless-{16 hex символов}"
+func namespaceFromSub(sub string) string {
+	hash := sha256.Sum256([]byte(sub))
+	return fmt.Sprintf("sless-%x", hash[:8])
+}
+
+func apiGet[T any](url, authHeader string) (T, error) {
+	var zero T
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return zero, err
+	}
+	req.Header.Set("Authorization", authHeader)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return zero, err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		return zero, fmt.Errorf("status %d: %s", resp.StatusCode, body)
+	}
+	if err := json.Unmarshal(body, &zero); err != nil {
+		return zero, fmt.Errorf("unmarshal: %w", err)
+	}
+	return zero, nil
+}
+
+func env(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}