chore: ignore *.tfvars (contains secrets)

- sqs-consumer: new Go binary v1.2 with tokenManager (auto-login /auth/login, 5min cache, retry on 401)
- console: add MQ/KW triggers UI (mqtriggers.go, kwtriggers.go, mq.js)
- console: update python-env image to v1.1 (boto3+psycopg2+requests)
- weather-demo: fix consumer/main.py (Flask Request.get_json instead of dict access)
- weather-demo: fix fetcher/main.py (boto3 SQS publish, 5 cities)
- weather-demo: update main.tf (python-env v1.1, deploy_type=literal)
- python-env: add psycopg2-binary to Dockerfile (v1.1)
- terraform provider: client auth fix

.github/copilot-instructions.md

@@ -28,16 +28,16 @@
 1. Не трогать рабочий код без явного указания.
 
 2. Файлы редактируются локально:
-   ~/fission
+   ~/IoT
 
-   После ЛЮБЫХ изменений ОБЯЗАТЕЛЬНО синхронизировать на ВМ командой:
-   rsync -az \
-     -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
-     ~/fission/ \
-     naeel@5.172.178.213:~/terra/fission/
+    После ЛЮБЫХ изменений ОБЯЗАТЕЛЬНО синхронизировать на ВМ командой:
+    rsync -az \
+       -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+       ~/IoT/ \
+       naeel@5.172.178.213:~/terra/IoT/
 
 
-3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/fission
+3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/IoT
 4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ:
    ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 'КОМАНДА'
 

.github/pravila.md

@@ -13,14 +13,14 @@
 
 ## Файловая система (актуально)
 
-1. Все файлы редактируются локально: `~/fission`
+1. Все файлы редактируются локально: `~/IoT`
 2. После любых изменений — обязательно rsync на ВМ:
    rsync -az \
      -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
-     ~/fission/ \
-     naeel@5.172.178.213:~/terra/fission/
+     ~/IoT/ \
+     naeel@5.172.178.213:~/terra/IoT/
 
-3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/fission
+3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/IoT
 4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ
 5. Перед запуском любой команды на ВМ обязательно убедиться, что синхронизация (rsync) выполнена
 6. SCP, sshfs, remote_dev и маунты больше НЕ используются
@@ -86,7 +86,7 @@ LOG="test-results/$(date +%Y-%m-%d_%H-%M).log"
 ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no naeel@5.172.178.213 \
   "bash ~/terra/fission/scripts/run_all.sh 2>&1 | tee ~/terra/fission/${LOG}"
 rsync -az -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no" \
-  naeel@5.172.178.213:~/terra/fission/test-results/ ~/fission/test-results/
+  naeel@5.172.178.213:~/terra/IoT/test-results/ ~/IoT/test-results/
 ```
 
 **Никогда не разбираться с результатами по памяти / буферу / чату. Только лог.**

.gitignore

@@ -2,6 +2,7 @@
 .terraform/
 *.tfstate
 *.tfstate.*
+*.tfvars
 
 # Go
 bin/

TODO.txt

@@ -0,0 +1,20 @@
+MQ-триггер (MessageQueue) — запуск при появлении сообщения в очереди (Kafka, NATS, RabbitMQ и т.д.)
+Kube-Watch триггер — запуск при изменении объектов в Kubernetes - а это разве может быть реализовано ?
+
+В Fission — да, это штатные встроенные типы триггеров. Fission из коробки поддерживает MQ (Kafka, NATS, Azure Queue) и Kube-Watch через отдельные компоненты (kubewatcher, mqtrigger).
+
+Но в вашей консоли это не реализовано — нет UI для создания/управления этими триггерами. Только HTTP и Cron. Если потребуется — можно добавить.
+
+от что реально полезно и не очень сложно:
+
+Для пользователя:
+
+История вызовов — последние N вызовов функции: время, статус, время ответа. Сейчас вызвал и забыл.
+Метрики — счётчик вызовов, средний latency, % ошибок. У вас уже есть metrics-collector — данные есть, нужен только UI.
+Автообновление логов — сейчас нужно жать "Обновить" вручную. Можно автополлинг каждые 3-5 сек.
+Копировать маршрут одной кнопкой — иконка 📋 рядом с маршрутом в таблице.
+Статус функции — Ready/NotReady/Error прямо в таблице (сейчас не видно).
+Для управления:
+6. Клонировать функцию — создать копию с новым именем, сохранив код и настройки.
+7. Экспорт/импорт — скачать функцию как zip, загрузить обратно.
+8. Переменные окружения — env vars для функции через UI (сейчас нельзя задать).

console/cmd/server/main.go

@@ -12,6 +12,8 @@ import (
 
 	"fission-console/internal/api"
 	"fission-console/internal/auth"
+	"fission-console/internal/billing"
+	"fission-console/internal/stats"
 
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/kubernetes"
@@ -48,6 +50,9 @@ func main() {
 		Demo: &auth.DemoAuthenticator{},
 	}
 
+	billingStore := billing.NewStore()
+	statsProvider := stats.NewProvider()
+
 	srv := api.NewServer(api.Config{
 		Dyn:           dyn,
 		Kube:          kube,
@@ -64,6 +69,8 @@ func main() {
 		LLMUrl: envDefault("FISSION_LLM_URL", "https://api.aillm.ru"),
 		LLMKey: os.Getenv("FISSION_LLM_KEY"),
 		// --- end ai/ask feature ---
+		Billing: billingStore,
+		Stats:   statsProvider,
 	})
 
 	// Запускаем фоновые горутины: reaper истёкших функций

console/deploy/console.yaml

@@ -15,9 +15,12 @@ rules:
   - apiGroups: [""]
     resources: ["pods/log"]
     verbs: ["get"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["get", "list", "create", "delete"]
   - apiGroups: ["apps"]
     resources: ["deployments"]
-    verbs: ["get", "list", "update", "patch"]
+    verbs: ["get", "list", "create", "update", "patch", "delete"]
   - apiGroups: ["fission.io"]
     resources: ["environments", "packages", "functions", "httptriggers", "timetriggers"]
     verbs: ["get", "list", "create", "update", "patch", "delete"]
@@ -55,7 +58,7 @@ spec:
       serviceAccountName: fission-console
       containers:
         - name: console
-          image: naeel/fission-console:v1.3.69
+          image: naeel/fission-console:v1.3.88
           imagePullPolicy: Always
           ports:
             - containerPort: 8090
@@ -82,6 +85,16 @@ spec:
                   key: password
             - name: FISSION_STORAGESVC_URL
               value: "http://storagesvc.fission.svc.cluster.local"
+            - name: BILLING_DSN
+              value: "postgres://super:BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432/sqsdb"
+            - name: GRAFANA_INTERNAL_URL
+              value: "http://grafana.grafana.svc.cluster.local:3000"
+            - name: GRAFANA_PUBLIC_URL
+              value: "https://fission.kube5s.ru/grafana"
+            - name: GRAFANA_ADMIN_USER
+              value: "admin"
+            - name: GRAFANA_ADMIN_PASS
+              value: "GrafanaAdmin2026!"
           livenessProbe:
             httpGet:
               path: /health

console/go.mod

@@ -20,6 +20,10 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/gnostic-models v0.7.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/pgx/v5 v5.9.2 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
@@ -32,6 +36,7 @@ require (
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/oauth2 v0.30.0 // indirect
+	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/term v0.37.0 // indirect
 	golang.org/x/text v0.31.0 // indirect

console/go.sum

@@ -29,6 +29,14 @@ github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgY
 github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144=
 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/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw=
+github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -70,6 +78,7 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
@@ -99,6 +108,8 @@ golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKl
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

console/internal/api/ai_prompts.go

@@ -255,6 +255,8 @@ func buildChatSystemPrompt() string {
 - **Cron** — можно включить/выключить и изменить расписание
 - **Код** — редактируется (для функций созданных из кода)
 - **Заменить архив** — загрузить новый zip (для функций из архива)
+- **Переменные окружения** — раздел в конце редактора. Кнопка "+ Добавить" добавляет переменную (имя + значение). Кнопка "Сохранить env vars" применяет изменения. Переменные сразу доступны в поде функции через os.environ (Python), process.env (Node.js), os.Getenv (Go) и т.д.
+- **📋 Клон** — кнопка в нижней панели. Позволяет создать копию функции с новым именем. Клон наследует код, язык, entrypoint, timeout. Маршрут назначается автоматически.
 
 ## Вызов функции (кнопка Вызов)
 Открывается модальное окно. Можно указать тело запроса (JSON) и нажать "Вызвать".
@@ -318,12 +320,7 @@ Ruby (entrypoint: handler):
 - ` + "`@hourly`" + `, ` + "`@daily`" + `, ` + "`@weekly`" + ` — стандартные псевдонимы
 
 ## ESC и закрытие окон
-Нажатие ESC закрывает любое открытое окно (модалку).
-
-## Чем НЕ занимаешься
-- Не рассказываешь про устройство платформы изнутри
-- Не помогаешь с инфраструктурой, деплоем, kubernetes
-- Не отвечаешь на вопросы не связанные с работой в консоли`)
+Нажатие ESC закрывает любое открытое окно (модалку).`)
 }
 
 func prettyLanguageName(lang string) string {

console/internal/api/function_clone.go

@@ -0,0 +1,333 @@
+// Package api — клонирование функций.
+//
+// handleCloneFunction создаёт полную копию функции с новым именем:
+//   - скачивает архив из storagesvc (или копирует literal)
+//   - заливает новый архив (отдельный объект в S3)
+//   - создаёт новый Package, Function и HTTPTrigger
+//
+// Архив переливается заново, чтобы удаление оригинала не сломало клон.
+package api
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+
+	"fission-console/internal/billing"
+	"fission-console/internal/fission"
+	"fission-console/internal/runtime"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// handleCloneFunction — POST /functions/:name/clone
+// Body: {"new_name": "my-clone", "route": "/my-clone"}  (route необязателен)
+func (s *Server) handleCloneFunction(w http.ResponseWriter, r *http.Request, srcName string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	var req struct {
+		NewName string `json:"new_name"`
+		Route   string `json:"route"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+	req.NewName = strings.TrimSpace(req.NewName)
+	req.Route = strings.TrimSpace(req.Route)
+
+	// Валидация нового имени
+	if req.NewName == "" {
+		writeJSONError(w, http.StatusBadRequest, "new_name is required")
+		return
+	}
+	validName := regexp.MustCompile(`^[a-z0-9]([a-z0-9-]*[a-z0-9])?$`)
+	if !validName.MatchString(req.NewName) || len(req.NewName) > 57 {
+		writeJSONError(w, http.StatusBadRequest, "invalid new_name: must match ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$ and be <= 57 chars")
+		return
+	}
+
+	// Получаем исходную функцию
+	srcFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, srcName, metav1.GetOptions{})
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", srcName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function: %v", err))
+		return
+	}
+
+	// Получаем имя пакета исходной функции
+	srcPkgName, _, _ := unstructured.NestedString(srcFn.Object, "spec", "package", "packageref", "name")
+	if srcPkgName == "" {
+		writeJSONError(w, http.StatusBadGateway, "source function has no package reference")
+		return
+	}
+
+	// Получаем исходный Package
+	srcPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, srcPkgName, metav1.GetOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get source package: %v", err))
+		return
+	}
+
+	// Скачиваем байты архива из Package
+	archiveBytes, err := s.downloadPackageBytes(ctx, srcPkg)
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("download archive: %v", err))
+		return
+	}
+
+	// Загружаем как новый архив
+	newDeploySpec, err := s.buildDeploySpec(ctx, archiveBytes)
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("upload clone archive: %v", err))
+		return
+	}
+
+	// Параметры для нового пакета (берём spec из оригинала)
+	now := time.Now().UTC()
+	newPkgName := req.NewName + "-" + now.Format("20060102150405")
+
+	// Определяем environment из исходной функции
+	envName, _, _ := unstructured.NestedString(srcFn.Object, "spec", "environment", "name")
+
+	// Собираем spec пакета (аналогично оригиналу, но с новыми байтами)
+	// Если у оригинала есть source (Go) — копируем source spec
+	srcSourceSpec, _, _ := unstructured.NestedMap(srcPkg.Object, "spec", "source")
+	hasBuildCmd, _, _ := unstructured.NestedString(srcPkg.Object, "spec", "buildcommand")
+
+	var newPkgSpec map[string]any
+	if hasBuildCmd != "" {
+		// Go: source package
+		newPkgSpec = map[string]any{
+			"source":       newDeploySpec, // перезаливаем source
+			"deployment":   map[string]any{},
+			"environment":  map[string]any{"name": envName, "namespace": ns},
+			"buildcommand": hasBuildCmd,
+		}
+		_ = srcSourceSpec
+	} else {
+		newPkgSpec = map[string]any{
+			"deployment":  newDeploySpec,
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		}
+	}
+
+	newPkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": newPkgName, "namespace": ns},
+		"spec":       newPkgSpec,
+	}}
+	if _, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create clone package: %v", err))
+		return
+	}
+
+	// Копируем аннотации из исходной функции
+	srcAnnotations := srcFn.GetAnnotations()
+	newAnnotations := map[string]any{
+		functionCreatedAtAnnotation: now.Format(time.RFC3339),
+		functionUpdatedAtAnnotation: now.Format(time.RFC3339),
+	}
+	for _, k := range []string{
+		"fission-console/language",
+		fissionSourceTypeAnnotation,
+		"fission-console/env-vars",
+		"fission-console/archive-filename",
+	} {
+		if v, ok := srcAnnotations[k]; ok && v != "" {
+			newAnnotations[k] = v
+		}
+	}
+	newAnnotations["fission-console/cloned-from"] = srcName
+
+	// Копируем entrypoint
+	entrypoint, _, _ := unstructured.NestedString(srcFn.Object, "spec", "package", "functionName")
+	timeout, _, _ := unstructured.NestedInt64(srcFn.Object, "spec", "functionTimeout")
+	if timeout == 0 {
+		timeout = 60
+	}
+
+	// Копируем InvokeStrategy и podspec
+	invokeStrategy, _, _ := unstructured.NestedMap(srcFn.Object, "spec", "InvokeStrategy")
+	if invokeStrategy == nil {
+		invokeStrategy = map[string]any{
+			"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+			"StrategyType":      "execution",
+		}
+	}
+	podspec, _, _ := unstructured.NestedMap(srcFn.Object, "spec", "podspec")
+
+	newFnSpec := map[string]any{
+		"environment":     map[string]any{"name": envName, "namespace": ns},
+		"functionTimeout": timeout,
+		"InvokeStrategy":  invokeStrategy,
+		"package": map[string]any{
+			"packageref":   map[string]any{"name": newPkgName, "namespace": ns},
+			"functionName": entrypoint,
+		},
+	}
+	if len(podspec) > 0 {
+		newFnSpec["podspec"] = podspec
+	}
+
+	newFn := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata": map[string]any{
+			"name":        req.NewName,
+			"namespace":   ns,
+			"annotations": newAnnotations,
+		},
+		"spec": newFnSpec,
+	}}
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Create(ctx, newFn, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.NewName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create clone function: %v", err))
+		return
+	}
+
+	// Маршрут для нового триггера
+	if req.Route == "" {
+		nsShort := ns
+		if len(nsShort) > 12 {
+			nsShort = nsShort[len(nsShort)-12:]
+		}
+		req.Route = "/" + nsShort + "/" + req.NewName
+	}
+	if !strings.HasPrefix(req.Route, "/") {
+		req.Route = "/" + req.Route
+	}
+	triggerName := req.NewName + "-route"
+
+	// Определяем методы из существующего триггера оригинала
+	methods := s.getTriggerMethods(ctx, ns, srcName)
+	if len(methods) == 0 {
+		methods = []any{"GET"}
+	}
+
+	newTrigger := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "HTTPTrigger",
+		"metadata":   map[string]any{"name": triggerName, "namespace": ns},
+		"spec": map[string]any{
+			"relativeurl":   req.Route,
+			"methods":       methods,
+			"createingress": true,
+			"functionref":   map[string]any{"type": "name", "name": req.NewName},
+		},
+	}}
+	if _, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Create(ctx, newTrigger, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, req.NewName, metav1.DeleteOptions{})
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create httptrigger: %v", err))
+		return
+	}
+
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: req.NewName,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    now,
+		StatusCode:   http.StatusCreated,
+		RecordedBy:   "console",
+		EventType:    "clone",
+	})
+
+	writeAnyJSON(w, http.StatusCreated, map[string]any{
+		"name":        req.NewName,
+		"cloned_from": srcName,
+		"package":     newPkgName,
+		"route":       req.Route,
+	})
+}
+
+// downloadPackageBytes извлекает байты архива из Package CRD.
+// Поддерживает type:url (скачивает из storagesvc) и type:literal (base64).
+func (s *Server) downloadPackageBytes(ctx context.Context, pkg *unstructured.Unstructured) ([]byte, error) {
+	// Пробуем deployment сначала, потом source (для Go)
+	for _, field := range [][]string{{"spec", "deployment"}, {"spec", "source"}} {
+		spec, _, _ := unstructured.NestedMap(pkg.Object, field...)
+		if len(spec) == 0 {
+			continue
+		}
+		archiveType, _ := spec["type"].(string)
+		switch archiveType {
+		case "url":
+			archiveURL, _ := spec["url"].(string)
+			if archiveURL == "" {
+				continue
+			}
+			return s.downloadFromStoragesvc(ctx, archiveURL)
+		case "literal":
+			lit, _ := spec["literal"].(string)
+			if lit == "" {
+				continue
+			}
+			return base64.StdEncoding.DecodeString(lit)
+		}
+	}
+	// Последний шанс: если функция Python с простым кодом — возвращаем заглушку
+	return nil, fmt.Errorf("no downloadable archive found in package (empty deployment and source spec)")
+}
+
+// downloadFromStoragesvc скачивает архив по URL из storagesvc.
+func (s *Server) downloadFromStoragesvc(ctx context.Context, archiveURL string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, archiveURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("build download request: %w", err)
+	}
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("download archive: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("download archive status %d", resp.StatusCode)
+	}
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read archive body: %w", err)
+	}
+	return data, nil
+}
+
+// getTriggerMethods возвращает методы HTTP из триггера функции (для копирования в клон).
+func (s *Server) getTriggerMethods(ctx context.Context, ns, fnName string) []any {
+	triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		return nil
+	}
+	for _, t := range triggers.Items {
+		ref, _, _ := unstructured.NestedString(t.Object, "spec", "functionref", "name")
+		if ref != fnName {
+			continue
+		}
+		methods, _, _ := unstructured.NestedSlice(t.Object, "spec", "methods")
+		if len(methods) > 0 {
+			return methods
+		}
+	}
+	return nil
+}
+
+// Ссылка на runtime.DefaultEntrypoint для возможного использования в будущем
+var _ = runtime.DefaultEntrypoint

console/internal/api/function_clone_test.go

@@ -0,0 +1,629 @@
+package api
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"fission-console/internal/fission"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	k8sruntime "k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	dynamicfake "k8s.io/client-go/dynamic/fake"
+)
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+
+// newCloneTestServer создаёт Server с фиктивным k8s-клиентом и
+// опциональным HTTP-сервером, имитирующим storagesvc.
+func newCloneTestServer(t *testing.T, storagesvcHandler http.HandlerFunc, objs ...*unstructured.Unstructured) (*Server, *httptest.Server) {
+	t.Helper()
+	scheme := k8sruntime.NewScheme()
+	listKinds := map[schema.GroupVersionResource]string{
+		fission.FunctionGVR: "FunctionList",
+		fission.PackageGVR:  "PackageList",
+		fission.HTTPTrigGVR: "HTTPTriggerList",
+	}
+	runtimeObjs := make([]k8sruntime.Object, len(objs))
+	for i, o := range objs {
+		runtimeObjs[i] = o
+	}
+	dynClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, listKinds, runtimeObjs...)
+
+	var storagesvc *httptest.Server
+	httpClient := &http.Client{}
+	if storagesvcHandler != nil {
+		storagesvc = httptest.NewServer(storagesvcHandler)
+		httpClient = storagesvc.Client()
+	}
+
+	s := &Server{
+		dyn:  dynClient,
+		ns:   "fission-test",
+		http: httpClient,
+	}
+	return s, storagesvc
+}
+
+// cloneRequest выполняет POST /functions/:srcName/clone с телом body.
+func cloneRequest(t *testing.T, s *Server, srcName, body string) *httptest.ResponseRecorder {
+	t.Helper()
+	req := httptest.NewRequest(http.MethodPost,
+		"/console/api/functions/"+srcName+"/clone",
+		strings.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Auth-Token", "test-token")
+	rec := httptest.NewRecorder()
+	s.handleCloneFunction(rec, req, srcName)
+	return rec
+}
+
+// makeZip возвращает минимальный zip-архив с одним файлом filename/content.
+func makeZip(t *testing.T, filename, content string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	w := zip.NewWriter(&buf)
+	f, err := w.Create(filename)
+	if err != nil {
+		t.Fatalf("zip.Create: %v", err)
+	}
+	if _, err := io.WriteString(f, content); err != nil {
+		t.Fatalf("zip.Write: %v", err)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("zip.Close: %v", err)
+	}
+	return buf.Bytes()
+}
+
+// packageWithLiteral создаёт Package CRD с type:literal (base64-encoded bytes).
+func packageWithLiteral(ns, name, fnName string, data []byte) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": name, "namespace": ns},
+		"spec": map[string]any{
+			"deployment": map[string]any{
+				"type":    "literal",
+				"literal": base64.StdEncoding.EncodeToString(data),
+			},
+			"environment": map[string]any{"name": fnName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+}
+
+// packageWithURL создаёт Package CRD с type:url.
+func packageWithURL(ns, pkgName, envName, archiveURL string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": pkgName, "namespace": ns},
+		"spec": map[string]any{
+			"deployment": map[string]any{
+				"type": "url",
+				"url":  archiveURL,
+			},
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+}
+
+// functionWithPkg создаёт Function CRD, ссылающуюся на pkgName.
+func functionWithPkg(ns, fnName, pkgName, envName, entrypoint string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata": map[string]any{
+			"name":      fnName,
+			"namespace": ns,
+			"annotations": map[string]any{
+				"fission-console/language":    envName,
+				"fission-console/source-type": "code",
+				"fission-console/created-at":  "2026-05-09T00:00:00Z",
+				"fission-console/updated-at":  "2026-05-09T00:00:00Z",
+			},
+		},
+		"spec": map[string]any{
+			"environment":     map[string]any{"name": envName, "namespace": ns},
+			"functionTimeout": int64(120),
+			"package": map[string]any{
+				"packageref":   map[string]any{"name": pkgName, "namespace": ns},
+				"functionName": entrypoint,
+			},
+			"InvokeStrategy": map[string]any{
+				"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+				"StrategyType":      "execution",
+			},
+		},
+	}}
+}
+
+// httpTriggerObject создаёт HTTPTrigger CRD для функции fnName.
+func httpTriggerObject(ns, trigName, fnName, route string, methods []any) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "HTTPTrigger",
+		"metadata":   map[string]any{"name": trigName, "namespace": ns},
+		"spec": map[string]any{
+			"relativeurl":   route,
+			"methods":       methods,
+			"createingress": true,
+			"functionref":   map[string]any{"type": "name", "name": fnName},
+		},
+	}}
+}
+
+// ─── Тесты валидации имени ───────────────────────────────────────────────────
+
+func TestHandleCloneFunction_InvalidName_EmptyName(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":""}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "new_name is required") {
+		t.Fatalf("body should mention 'new_name is required', got: %s", rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_UpperCase(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"MyFunc"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_StartsWithDash(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"-bad"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_EndsWithDash(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"bad-"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_TooLong(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	longName := strings.Repeat("a", 58)
+	rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, longName))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_ValidName_MaxLength(t *testing.T) {
+	// 57 символов — допустимо; но функция src не существует → 404
+	s, _ := newCloneTestServer(t, nil)
+	name57 := strings.Repeat("a", 57)
+	rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, name57))
+	// Ожидаем не 400 (прошло валидацию), а 404 (src не найден)
+	if rec.Code == http.StatusBadRequest {
+		t.Fatalf("57-char name should pass validation, got 400; body=%s", rec.Body)
+	}
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_ValidName_WithDashes(t *testing.T) {
+	// Имя вида "a-b-c" — допустимо
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "nonexist", `{"new_name":"a-b-c"}`)
+	if rec.Code == http.StatusBadRequest {
+		t.Fatalf("'a-b-c' should pass validation, got 400; body=%s", rec.Body)
+	}
+}
+
+// ─── Тест: источник не существует ────────────────────────────────────────────
+
+func TestHandleCloneFunction_SourceNotFound(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "ghost", `{"new_name":"ghost-copy"}`)
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "ghost") {
+		t.Fatalf("body should mention 'ghost', got: %s", rec.Body)
+	}
+}
+
+// ─── Тест: успешный клон с type:literal ──────────────────────────────────────
+
+func TestHandleCloneFunction_Success_Literal(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hello'\n")
+
+	pkg := packageWithLiteral(ns, "src-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "src", "src-pkg", "python", "main.main")
+	trig := httpTriggerObject(ns, "src-route", "src", "/test-ns/src", []any{"GET", "POST"})
+
+	// storagesvc принимает загрузку и возвращает URL
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodPost {
+			// Имитируем загрузку — возвращаем ID архива
+			w.Header().Set("Content-Type", "application/json")
+			fmt.Fprint(w, `{"id":"fission/new-archive-id-123"}`)
+			return
+		}
+		http.NotFound(w, r)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, trig)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "src", `{"new_name":"src-copy"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	var resp map[string]any
+	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if resp["name"] != "src-copy" {
+		t.Fatalf("response.name = %v, want 'src-copy'", resp["name"])
+	}
+	if resp["cloned_from"] != "src" {
+		t.Fatalf("response.cloned_from = %v, want 'src'", resp["cloned_from"])
+	}
+	if resp["package"] == "" || resp["package"] == nil {
+		t.Fatalf("response.package is empty")
+	}
+
+	ctx := context.Background()
+
+	// Проверяем что Function создана
+	cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "src-copy", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone Function not found: %v", err)
+	}
+
+	// Аннотация cloned-from
+	ann := cloneFn.GetAnnotations()
+	if ann["fission-console/cloned-from"] != "src" {
+		t.Fatalf("annotation cloned-from = %q, want 'src'", ann["fission-console/cloned-from"])
+	}
+	// Аннотации language и source-type скопированы
+	if ann["fission-console/language"] != "python" {
+		t.Fatalf("annotation language = %q, want 'python'", ann["fission-console/language"])
+	}
+	if ann["fission-console/source-type"] != "code" {
+		t.Fatalf("annotation source-type = %q, want 'code'", ann["fission-console/source-type"])
+	}
+
+	// Entrypoint скопирован
+	ep, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "functionName")
+	if ep != "main.main" {
+		t.Fatalf("entrypoint = %q, want 'main.main'", ep)
+	}
+
+	// Timeout скопирован
+	timeout, _, _ := unstructured.NestedInt64(cloneFn.Object, "spec", "functionTimeout")
+	if timeout != 120 {
+		t.Fatalf("timeout = %d, want 120", timeout)
+	}
+
+	// Проверяем что HTTPTrigger создан
+	trigName := "src-copy-route"
+	cloneTrig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, trigName, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone HTTPTrigger not found: %v", err)
+	}
+
+	// Методы скопированы из оригинального триггера
+	methods, _, _ := unstructured.NestedStringSlice(cloneTrig.Object, "spec", "methods")
+	if len(methods) != 2 {
+		t.Fatalf("methods = %v, want [GET POST]", methods)
+	}
+
+	// Маршрут сгенерирован автоматически (содержит new_name)
+	route, _, _ := unstructured.NestedString(cloneTrig.Object, "spec", "relativeurl")
+	if !strings.HasSuffix(route, "/src-copy") {
+		t.Fatalf("route = %q, should end with '/src-copy'", route)
+	}
+}
+
+// ─── Тест: маршрут задан явно ────────────────────────────────────────────────
+
+func TestHandleCloneFunction_CustomRoute(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hi'\n")
+
+	pkg := packageWithLiteral(ns, "fn-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "fn", "fn-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-456"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "fn", `{"new_name":"fn-clone","route":"/custom/path"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn-clone-route", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("HTTPTrigger not found: %v", err)
+	}
+	route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+	if route != "/custom/path" {
+		t.Fatalf("route = %q, want '/custom/path'", route)
+	}
+}
+
+// ─── Тест: маршрут без слеша — добавляется автоматически ─────────────────────
+
+func TestHandleCloneFunction_RouteWithoutLeadingSlash(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hi'\n")
+
+	pkg := packageWithLiteral(ns, "fn2-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "fn2", "fn2-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-789"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "fn2", `{"new_name":"fn2-clone","route":"no-leading-slash"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn2-clone-route", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("HTTPTrigger not found: %v", err)
+	}
+	route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+	if !strings.HasPrefix(route, "/") {
+		t.Fatalf("route = %q, should start with '/'", route)
+	}
+}
+
+// ─── Тест: дублирующее имя → 409 ─────────────────────────────────────────────
+
+func TestHandleCloneFunction_DuplicateName_Conflict(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'a'\n")
+
+	pkg := packageWithLiteral(ns, "dup-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "dup-src", "dup-pkg", "python", "main.main")
+	// Уже существующая функция с именем "dup-copy"
+	existingFn := functionWithPkg(ns, "dup-copy", "other-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-dup"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "dup-src", `{"new_name":"dup-copy"}`)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "dup-copy") {
+		t.Fatalf("body should mention 'dup-copy', got: %s", rec.Body)
+	}
+}
+
+// ─── Тест: откат при ошибке создания Function ────────────────────────────────
+
+func TestHandleCloneFunction_Rollback_OnFunctionConflict(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'rb'\n")
+
+	pkg := packageWithLiteral(ns, "rb-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "rb-src", "rb-pkg", "python", "main.main")
+	// Уже существующая функция с именем клона
+	existingFn := functionWithPkg(ns, "rb-clone", "other-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-rb"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "rb-src", `{"new_name":"rb-clone"}`)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
+	}
+
+	// После rollback Package с именем "rb-clone-*" не должен остаться
+	ctx := context.Background()
+	pkgs, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		t.Fatalf("list packages: %v", err)
+	}
+	for _, p := range pkgs.Items {
+		if strings.HasPrefix(p.GetName(), "rb-clone-") {
+			t.Fatalf("rollback failed: package %q still exists", p.GetName())
+		}
+	}
+}
+
+// ─── Тест: downloadPackageBytes — type:literal ────────────────────────────────
+
+func TestDownloadPackageBytes_Literal(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+
+	original := []byte("hello from literal")
+	pkg := packageWithLiteral("fission-test", "lit-pkg", "python", original)
+
+	got, err := s.downloadPackageBytes(context.Background(), pkg)
+	if err != nil {
+		t.Fatalf("downloadPackageBytes error: %v", err)
+	}
+	if !bytes.Equal(got, original) {
+		t.Fatalf("got %q, want %q", got, original)
+	}
+}
+
+// ─── Тест: downloadPackageBytes — type:url ────────────────────────────────────
+
+func TestDownloadPackageBytes_URL(t *testing.T) {
+	const content = "archive-content-from-storagesvc"
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, content)
+	}))
+	defer srv.Close()
+
+	pkg := packageWithURL("fission-test", "url-pkg", "python", srv.URL+"/v1/archive?id=abc")
+	s := &Server{http: srv.Client()}
+
+	got, err := s.downloadPackageBytes(context.Background(), pkg)
+	if err != nil {
+		t.Fatalf("downloadPackageBytes error: %v", err)
+	}
+	if string(got) != content {
+		t.Fatalf("got %q, want %q", got, content)
+	}
+}
+
+// ─── Тест: downloadPackageBytes — пустой Package → ошибка ────────────────────
+
+func TestDownloadPackageBytes_EmptyPackage_Error(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	emptyPkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": "empty", "namespace": "fission-test"},
+		"spec":       map[string]any{},
+	}}
+	_, err := s.downloadPackageBytes(context.Background(), emptyPkg)
+	if err == nil {
+		t.Fatal("expected error for empty package, got nil")
+	}
+}
+
+// ─── Тест: downloadFromStoragesvc — non-200 → ошибка ────────────────────────
+
+func TestDownloadFromStoragesvc_Non200(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	s := &Server{http: srv.Client()}
+	_, err := s.downloadFromStoragesvc(context.Background(), srv.URL+"/v1/archive?id=gone")
+	if err == nil {
+		t.Fatal("expected error for 404 response, got nil")
+	}
+	if !strings.Contains(err.Error(), "404") {
+		t.Fatalf("error should mention 404, got: %v", err)
+	}
+}
+
+// ─── Тест: getTriggerMethods — триггер существует ────────────────────────────
+
+func TestGetTriggerMethods_Found(t *testing.T) {
+	const ns = "fission-test"
+	trig := httpTriggerObject(ns, "my-trig", "my-fn", "/my", []any{"GET", "POST"})
+	s, _ := newCloneTestServer(t, nil, trig)
+
+	methods := s.getTriggerMethods(context.Background(), ns, "my-fn")
+	if len(methods) != 2 {
+		t.Fatalf("methods = %v, want 2 elements", methods)
+	}
+}
+
+// ─── Тест: getTriggerMethods — триггера нет → nil ────────────────────────────
+
+func TestGetTriggerMethods_NotFound(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	methods := s.getTriggerMethods(context.Background(), "fission-test", "no-such-fn")
+	if methods != nil {
+		t.Fatalf("expected nil, got %v", methods)
+	}
+}
+
+// ─── Тест: невалидный JSON body → 400 ────────────────────────────────────────
+
+func TestHandleCloneFunction_InvalidJSON(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	req := httptest.NewRequest(http.MethodPost, "/console/api/functions/src/clone",
+		strings.NewReader(`not-json`))
+	rec := httptest.NewRecorder()
+	s.handleCloneFunction(rec, req, "src")
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+// ─── Тест: успешный клон — Package содержит ссылку на Function ───────────────
+
+func TestHandleCloneFunction_PackageRefsCloneFunction(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'ref'\n")
+	pkg := packageWithLiteral(ns, "ref-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "ref-src", "ref-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-ref"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "ref-src", `{"new_name":"ref-clone"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "ref-clone", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone function not found: %v", err)
+	}
+
+	pkgRef, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "packageref", "name")
+	if !strings.HasPrefix(pkgRef, "ref-clone-") {
+		t.Fatalf("clone Function.spec.package.packageref.name = %q, should start with 'ref-clone-'", pkgRef)
+	}
+
+	// Package с этим именем должен существовать
+	_, err = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgRef, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone Package %q not found: %v", pkgRef, err)
+	}
+}

console/internal/api/function_code.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 	"time"
 
+	"fission-console/internal/billing"
 	"fission-console/internal/fission"
 	"fission-console/internal/model"
 	"fission-console/internal/runtime"
@@ -275,6 +276,16 @@ func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: req.Name,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    now,
+		StatusCode:   http.StatusCreated,
+		RecordedBy:   "console",
+		EventType:    "create",
+	})
+
 	writeAnyJSON(w, http.StatusCreated, map[string]any{
 		"name":        req.Name,
 		"package":     pkgName,

console/internal/api/function_crud.go

@@ -1,10 +1,12 @@
-// Package api — CRUD операции с функциями: чтение, удаление, обновление таймаута, логи.
+// Package api — CRUD операции с функциями: чтение, удаление, обновление таймаута, логи, env vars.
 //
 // Этот файл содержит операции, не связанные с заменой кода/архива:
-//   - handleGetFunction          — GET /functions/:name (детали: код, route, environment, source_type)
-//   - handleDeleteFunction       — DELETE /functions/:name (каскадное удаление: триггеры, Package, S3)
+//   - handleGetFunction           — GET /functions/:name (детали: код, route, environment, source_type)
+//   - handleDeleteFunction        — DELETE /functions/:name (каскадное удаление: триггеры, Package, S3)
 //   - handleUpdateFunctionTimeout — PUT /functions/:name/timeout (только таймаут, без замены кода)
-//   - handleGetFunctionLogs      — GET /functions/:name/logs (логи пода через Kubernetes API)
+//   - handleGetFunctionLogs       — GET /functions/:name/logs (логи пода через Kubernetes API)
+//   - handleGetFunctionEnvVars    — GET /functions/:name/envvars (переменные окружения из CRD)
+//   - handlePutFunctionEnvVars    — PUT /functions/:name/envvars (обновить env vars в CRD)
 //
 // Операции с кодом и архивом — в function_code.go и function_archive.go соответственно.
 // Вызов функции — в function_invoke.go.
@@ -19,12 +21,14 @@ import (
 	"strings"
 	"time"
 
+	"fission-console/internal/billing"
 	"fission-console/internal/fission"
 
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	k8stypes "k8s.io/apimachinery/pkg/types"
 )
 
 // handleGetFunction возвращает детали функции: код, environment, route, methods.
@@ -102,6 +106,7 @@ func (s *Server) handleGetFunction(w http.ResponseWriter, r *http.Request, name
 		"archive_filename": archiveFilename,
 		"route":            route,
 		"methods":          methods,
+		"env_vars":         extractEnvVars(fn),
 		"raw":              fn.Object,
 	})
 }
@@ -224,6 +229,16 @@ func (s *Server) handleDeleteFunction(w http.ResponseWriter, r *http.Request, na
 
 	// (reconciler NS удалён — за FISSION_RESOURCE_NAMESPACES теперь отвечает Layer 1 NSWatcher)
 
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: name,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    time.Now(),
+		StatusCode:   http.StatusOK,
+		RecordedBy:   "console",
+		EventType:    "delete",
+	})
+
 	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name, "package": pkgName})
 }
 
@@ -284,3 +299,226 @@ func (s *Server) handleGetFunctionLogs(w http.ResponseWriter, r *http.Request, n
 		"logs": allLogs.String(),
 	})
 }
+
+// handleGetFunctionEnvVars возвращает переменные окружения функции из .spec.runtime.container.env
+func (s *Server) handleGetFunctionEnvVars(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+
+	envVars := extractEnvVars(fn)
+	writeAnyJSON(w, http.StatusOK, map[string]any{"env_vars": envVars})
+}
+
+// handlePutFunctionEnvVars обновляет переменные окружения функции.
+//
+// Логика переключения ExecutorType:
+//   - Если env vars непустые → ExecutorType: newdeploy + spec.podspec.containers[0].env
+//     (newdeploy создаёт dedicated Deployment, Kubernetes ставит env vars на уровне ОС)
+//   - Если env vars пустые → ExecutorType: poolmgr, podspec удаляется
+//     (poolmgr использует warm pool, быстрый cold start)
+//
+// Это единственный универсальный способ передать env vars в pod для всех языков
+// (Python, Go, Ruby, PHP, Node.js) без изменений в env-серверах.
+func (s *Server) handlePutFunctionEnvVars(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	var req struct {
+		EnvVars []map[string]string `json:"env_vars"` // [{name: "KEY", value: "VAL"}, ...]
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+
+	// Валидация: имена переменных
+	for _, ev := range req.EnvVars {
+		k := ev["name"]
+		if k == "" {
+			writeJSONError(w, http.StatusBadRequest, "env var name cannot be empty")
+			return
+		}
+	}
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+
+	// Сериализуем в JSON для аннотации (для UI)
+	envJSON, err := json.Marshal(req.EnvVars)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("marshal env vars: %v", err))
+		return
+	}
+
+	// Обновляем аннотации
+	now := time.Now().UTC().Format(time.RFC3339)
+	ann := fn.GetAnnotations()
+	if ann == nil {
+		ann = map[string]string{}
+	}
+	ann[functionUpdatedAtAnnotation] = now
+	ann["fission-console/env-vars"] = string(envJSON)
+	fn.SetAnnotations(ann)
+
+	if len(req.EnvVars) > 0 {
+		// Есть env vars → newdeploy + podspec с env vars
+		envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+
+		// Строим список env vars для Kubernetes
+		envList := make([]any, 0, len(req.EnvVars))
+		for _, ev := range req.EnvVars {
+			envList = append(envList, map[string]any{
+				"name":  ev["name"],
+				"value": ev["value"],
+			})
+		}
+
+		// Устанавливаем podspec.containers[0] с env vars
+		// Имя контейнера = имя environment (стандарт Fission)
+		if err := unstructured.SetNestedSlice(fn.Object, []any{
+			map[string]any{
+				"name": envName,
+				"env":  envList,
+			},
+		}, "spec", "podspec", "containers"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set podspec: %v", err))
+			return
+		}
+
+		// Переключаем на newdeploy (только он поддерживает podspec env)
+		if err := unstructured.SetNestedField(fn.Object, map[string]any{
+			"ExecutionStrategy": map[string]any{
+				"ExecutorType":          "newdeploy",
+				"MinScale":              int64(0),
+				"MaxScale":              int64(1),
+				"SpecializationTimeout": int64(120),
+			},
+			"StrategyType": "execution",
+		}, "spec", "InvokeStrategy"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %v", err))
+			return
+		}
+	} else {
+		// Нет env vars → poolmgr, убираем podspec
+		unstructured.RemoveNestedField(fn.Object, "spec", "podspec")
+
+		if err := unstructured.SetNestedField(fn.Object, map[string]any{
+			"ExecutionStrategy": map[string]any{
+				"ExecutorType":          "poolmgr",
+				"SpecializationTimeout": int64(120),
+			},
+			"StrategyType": "execution",
+		}, "spec", "InvokeStrategy"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %v", err))
+			return
+		}
+	}
+
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update function %q: %v", name, err))
+		return
+	}
+
+	// Fission newdeploy НЕ применяет fn.Spec.PodSpec при построении Deployment.
+	// Поэтому напрямую патчим существующий Deployment через Kubernetes API.
+	if len(req.EnvVars) > 0 && s.kube != nil {
+		envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+		if envName != "" {
+			if err := s.patchDeploymentEnvVars(ctx, ns, name, envName, req.EnvVars); err != nil {
+				// Не фатальная ошибка — CRD обновлён, Deployment будет обновлён позже
+				_ = err // warn only
+			}
+		}
+	}
+
+	executor := "poolmgr"
+	if len(req.EnvVars) > 0 {
+		executor = "newdeploy"
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"updated": true, "count": len(req.EnvVars), "executor": executor})
+}
+
+// extractEnvVars читает аннотацию fission-console/env-vars (JSON) из Function CRD
+// Возвращает [{name, value}, ...]
+func extractEnvVars(fn *unstructured.Unstructured) []map[string]string {
+	ann := fn.GetAnnotations()
+	if ann == nil {
+		return []map[string]string{}
+	}
+	raw := ann["fission-console/env-vars"]
+	if raw == "" {
+		return []map[string]string{}
+	}
+	var result []map[string]string
+	if err := json.Unmarshal([]byte(raw), &result); err != nil {
+		return []map[string]string{}
+	}
+	return result
+}
+
+// patchDeploymentEnvVars находит Deployment newdeploy для функции и патчит его env vars.
+// Fission не применяет fn.Spec.PodSpec при построении Deployment, поэтому патчим напрямую.
+// Поиск по labels: functionName=<name>, functionNamespace=<ns>, executorType=newdeploy
+func (s *Server) patchDeploymentEnvVars(ctx context.Context, ns, fnName, envContainerName string, envVars []map[string]string) error {
+	selector := fmt.Sprintf("functionName=%s,functionNamespace=%s,executorType=newdeploy", fnName, ns)
+	deplList, err := s.kube.AppsV1().Deployments(ns).List(ctx, metav1.ListOptions{LabelSelector: selector})
+	if err != nil {
+		return fmt.Errorf("list deployments: %w", err)
+	}
+	if len(deplList.Items) == 0 {
+		return nil // Deployment ещё не создан Fission — ничего страшного
+	}
+
+	// Строим env vars для patch (StrategicMergePatch мержит по "name")
+	envItems := make([]map[string]string, 0, len(envVars))
+	for _, ev := range envVars {
+		envItems = append(envItems, map[string]string{"name": ev["name"], "value": ev["value"]})
+	}
+
+	patch := map[string]any{
+		"spec": map[string]any{
+			"template": map[string]any{
+				"spec": map[string]any{
+					"containers": []any{
+						map[string]any{
+							"name": envContainerName,
+							"env":  envItems,
+						},
+					},
+				},
+			},
+		},
+	}
+	patchBytes, err := json.Marshal(patch)
+	if err != nil {
+		return fmt.Errorf("marshal patch: %w", err)
+	}
+
+	for _, depl := range deplList.Items {
+		if _, err := s.kube.AppsV1().Deployments(ns).Patch(
+			ctx, depl.Name, k8stypes.StrategicMergePatchType, patchBytes, metav1.PatchOptions{},
+		); err != nil {
+			return fmt.Errorf("patch deployment %s: %w", depl.Name, err)
+		}
+	}
+	return nil
+}

console/internal/api/function_invoke.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 	"time"
 
+	"fission-console/internal/billing"
 	"fission-console/internal/fission"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -202,9 +203,26 @@ func (s *Server) handleInvokeFunction(w http.ResponseWriter, r *http.Request, na
 	defer resp.Body.Close()
 
 	respBody, _ := io.ReadAll(resp.Body)
+
+	durationMS := time.Since(start).Milliseconds()
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:     ns,
+		FunctionName:  name,
+		TriggerType:   billing.TriggerConsole,
+		Route:         invokeURL,
+		HTTPMethod:    invokeMethod,
+		StartedAt:     start,
+		DurationMS:    durationMS,
+		StatusCode:    resp.StatusCode,
+		RequestBytes:  int64(len(bodyBytes)),
+		ResponseBytes: int64(len(respBody)),
+		RecordedBy:    "console",
+		EventType:     "invoke",
+	})
+
 	writeAnyJSON(w, http.StatusOK, map[string]any{
 		"status":       resp.StatusCode,
-		"latency_ms":   time.Since(start).Milliseconds(),
+		"latency_ms":   durationMS,
 		"response_raw": string(respBody),
 	})
 }
@@ -311,9 +329,26 @@ func (s *Server) invokeInternalFunction(w http.ResponseWriter, r *http.Request,
 	defer resp.Body.Close()
 
 	respBody, _ := io.ReadAll(resp.Body)
+
+	durationMS := time.Since(start).Milliseconds()
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:     namespace,
+		FunctionName:  functionName,
+		TriggerType:   billing.TriggerHTTP,
+		Route:         extraPath,
+		HTTPMethod:    r.Method,
+		StartedAt:     start,
+		DurationMS:    durationMS,
+		StatusCode:    resp.StatusCode,
+		RequestBytes:  int64(len(bodyBytes)),
+		ResponseBytes: int64(len(respBody)),
+		RecordedBy:    "console",
+		EventType:     "invoke",
+	})
+
 	writeAnyJSON(w, http.StatusOK, map[string]any{
 		"status":       resp.StatusCode,
-		"latency_ms":   time.Since(start).Milliseconds(),
+		"latency_ms":   durationMS,
 		"response_raw": string(respBody),
 	})
 }

console/internal/api/handlers.go

@@ -25,7 +25,6 @@ import (
 	"time"
 
 	"fission-console/internal/auth"
-	"fission-console/internal/fission"
 )
 
 // validFuncName — RFC 1123 subdomain label: строчные буквы+цифры+дефис, без дефиса в начале/конце.
@@ -51,11 +50,11 @@ const fissionSourceTypeAnnotation = "fission-console/source-type"
 const defaultFunctionInvokeTimeout = 60 * time.Second
 
 // handleFunctionsRoot обрабатывает запросы к /console/api/functions без имени функции.
-// GET → список всех функций, POST → создать новую.
+// GET → список всех функций со статусами, POST → создать новую.
 func (s *Server) handleFunctionsRoot(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		s.handleList(fission.FunctionGVR)(w, r)
+		s.handleListFunctionsWithStatus(w, r)
 	case http.MethodPost:
 		s.handleCreateFunction(w, r)
 	default:
@@ -127,6 +126,25 @@ func (s *Server) handleFunctionsAction(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// /functions/:name/envvars — переменные окружения
+	if len(parts) == 2 && parts[1] == "envvars" {
+		switch r.Method {
+		case http.MethodGet:
+			s.handleGetFunctionEnvVars(w, r, name)
+		case http.MethodPut:
+			s.handlePutFunctionEnvVars(w, r, name)
+		default:
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		}
+		return
+	}
+
+	// /functions/:name/clone — клонировать функцию с новым именем
+	if len(parts) == 2 && parts[1] == "clone" && r.Method == http.MethodPost {
+		s.handleCloneFunction(w, r, name)
+		return
+	}
+
 	http.NotFound(w, r)
 }
 
@@ -163,6 +181,13 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
 		fmt.Printf("handleAuth: ensureUserNS %s: %v\n", ns, ensureErr)
 	}
 
+	// Провизируем Grafana Org для этого namespace (fire-and-forget, идемпотентно).
+	go func() {
+		if err := s.stats.EnsureOrgForNamespace(context.Background(), ns, identity.Email); err != nil {
+			fmt.Printf("handleAuth: EnsureOrgForNamespace %s: %v\n", ns, err)
+		}
+	}()
+
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "env": env, "namespace": ns, "email": identity.Email})
 }

console/internal/api/kwtriggers.go

@@ -0,0 +1,241 @@
+package api
+
+// kwtriggers.go — CRUD хендлеры для KubernetesWatchTrigger (Fission KW Trigger).
+//
+// РЕШЕНИЕ ПО АРХИТЕКТУРЕ (2026-05-11):
+//   KubernetesWatchTrigger позволяет вызывать функцию при изменении K8s объектов.
+//   spec.type      — тип ресурса: Pod, Service, Deployment, ConfigMap, и т.д.
+//   spec.namespace — namespace для слежения (по умолчанию = namespace пользователя)
+//   spec.labelselector — label selector в формате "key=value,key2=value2"
+//   spec.functionref — ссылка на функцию
+//
+// ОСОБЕННОСТИ:
+//   - Fission kubewatcher компонент должен быть задеплоен.
+//   - namespace в spec — это WATCHED namespace (не namespace триггера).
+//     Для безопасности ограничиваем: только namespace пользователя или пустое (тогда = userNS).
+//   - labelselector опционален, "" = смотрим на все ресурсы типа resourceType в namespace.
+//
+// ОШИБКИ В ПРОЦЕССЕ:
+//   - (нет, первая реализация)
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/fission"
+	"fission-console/internal/model"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// validKWResourceTypes — поддерживаемые типы ресурсов для слежения.
+// Расширяемо — это не ограничение CRD, просто UI-валидация.
+var validKWResourceTypes = map[string]struct{}{
+	"pod":         {},
+	"service":     {},
+	"deployment":  {},
+	"configmap":   {},
+	"secret":      {},
+	"namespace":   {},
+	"replicaset":  {},
+	"statefulset": {},
+	"daemonset":   {},
+	"job":         {},
+}
+
+func (s *Server) handleKWTriggersRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleList(fission.KWTrigGVR)(w, r)
+	case http.MethodPost:
+		s.handleCreateKWTrigger(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleKWTriggersAction(w http.ResponseWriter, r *http.Request) {
+	path := strings.TrimPrefix(r.URL.Path, "/console/api/kwtriggers/")
+	path = strings.TrimPrefix(path, "/api/kwtriggers/")
+	name := strings.Trim(path, "/")
+	if name == "" || strings.Contains(name, "/") {
+		http.NotFound(w, r)
+		return
+	}
+
+	switch r.Method {
+	case http.MethodGet:
+		s.handleGetKWTrigger(w, r, name)
+	case http.MethodDelete:
+		s.handleDeleteKWTrigger(w, r, name)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleCreateKWTrigger(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateKWTriggerRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+
+	ns := s.userNS(r)
+
+	// Если namespace не задан — используем namespace пользователя
+	if strings.TrimSpace(req.Namespace) == "" {
+		req.Namespace = ns
+	}
+
+	// Безопасность: нельзя смотреть за чужим namespace
+	if req.Namespace != ns {
+		writeJSONError(w, http.StatusForbidden, "can only watch your own namespace")
+		return
+	}
+
+	if err := validateKWTriggerRequest(req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	// Проверяем что функция существует
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, req.FunctionName, metav1.GetOptions{}); err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("function %q not found", req.FunctionName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function: %v", err))
+		return
+	}
+
+	obj := buildKWTriggerObject(ns, req)
+	created, err := s.dyn.Resource(fission.KWTrigGVR).Namespace(ns).Create(ctx, obj, metav1.CreateOptions{})
+	if err != nil {
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("kwtrigger %q already exists", req.Name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create kwtrigger: %v", err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, kwTriggerResponse(created))
+}
+
+func (s *Server) handleGetKWTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	obj, err := s.dyn.Resource(fission.KWTrigGVR).Namespace(s.userNS(r)).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get kwtrigger %q: %v", name, err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusOK, kwTriggerResponse(obj))
+}
+
+func (s *Server) handleDeleteKWTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	if err := s.dyn.Resource(fission.KWTrigGVR).Namespace(s.userNS(r)).Delete(ctx, name, metav1.DeleteOptions{}); err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("delete kwtrigger %q: %v", name, err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name})
+}
+
+// --- Вспомогательные функции ---
+
+func validateKWTriggerRequest(req model.CreateKWTriggerRequest) error {
+	if strings.TrimSpace(req.Name) == "" {
+		return fmt.Errorf("name is required")
+	}
+	if strings.TrimSpace(req.FunctionName) == "" {
+		return fmt.Errorf("functionName is required")
+	}
+	rt := strings.ToLower(strings.TrimSpace(req.ResourceType))
+	if _, ok := validKWResourceTypes[rt]; !ok {
+		return fmt.Errorf("resourceType must be one of: Pod, Service, Deployment, ConfigMap, Secret, Namespace, ReplicaSet, StatefulSet, DaemonSet, Job")
+	}
+	return nil
+}
+
+func buildKWTriggerObject(ns string, req model.CreateKWTriggerRequest) *unstructured.Unstructured {
+	// Fission ожидает capitalize: Pod, Service, Deployment
+	resourceType := capitalize(strings.TrimSpace(req.ResourceType))
+
+	spec := map[string]any{
+		"type":      resourceType,
+		"namespace": req.Namespace,
+		"functionref": map[string]any{
+			"type": "name",
+			"name": req.FunctionName,
+		},
+	}
+	if req.LabelSelector != "" {
+		spec["labelselector"] = req.LabelSelector
+	}
+
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "KubernetesWatchTrigger",
+		"metadata": map[string]any{
+			"name":      req.Name,
+			"namespace": ns,
+		},
+		"spec": spec,
+	}}
+}
+
+func kwTriggerResponse(obj *unstructured.Unstructured) map[string]any {
+	spec, _ := obj.Object["spec"].(map[string]any)
+	if spec == nil {
+		spec = map[string]any{}
+	}
+	fnref, _ := spec["functionref"].(map[string]any)
+	fnName := ""
+	if fnref != nil {
+		fnName, _ = fnref["name"].(string)
+	}
+	return map[string]any{
+		"metadata": map[string]any{
+			"name":      obj.GetName(),
+			"namespace": obj.GetNamespace(),
+		},
+		"spec": map[string]any{
+			"resourceType":  spec["type"],
+			"namespace":     spec["namespace"],
+			"labelSelector": spec["labelselector"],
+			"functionName":  fnName,
+		},
+	}
+}
+
+// capitalize приводит первый символ к верхнему регистру, остальное без изменений.
+// "pod" → "Pod", "deployment" → "Deployment"
+func capitalize(s string) string {
+	if s == "" {
+		return s
+	}
+	return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
+}

console/internal/api/mqtriggers.go

@@ -0,0 +1,286 @@
+package api
+
+// mqtriggers.go — CRUD для MQ-триггеров через K8s Deployment + Secret.
+//
+// АРХИТЕКТУРА (2026-05-11):
+//   Вместо Fission MessageQueueTrigger CRD (требует mqtrigger компонент Kafka/NATS)
+//   Console деплоит собственный sqs-consumer Deployment в namespace пользователя.
+//
+//   При CREATE:
+//     1. Создаём K8s Secret (sqs-mq-<name>) с SQS credentials
+//     2. Создаём K8s Deployment (mq-<name>) с образом naeel/sqs-consumer:v1.0
+//        FUNCTION_URL = http://router.fission.svc.cluster.local/<functionName>
+//     Лейблы: app.kubernetes.io/managed-by=fission-console, component=mq-trigger
+//
+//   При LIST: deployments -n <ns> -l component=mq-trigger
+//   При DELETE: удаляем Deployment + Secret
+//
+// ИЗМЕНЕНИЯ:
+//   v1 — использовал Fission MQ CRD (компонент отсутствует в кластере)
+//   v2 — K8s Deployment + наш sqs-consumer образ
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/model"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	sqsConsumerImage   = "naeel/sqs-consumer:v1.0"
+	sqsDefaultEndpoint = "http://shared-sqs.shared-sqs.svc.cluster.local:4100"
+	fissionRouterBase  = "http://router.fission.svc.cluster.local"
+	mqTriggerLabelKey  = "component"
+	mqTriggerLabelVal  = "mq-trigger"
+	mqManagedByLabel   = "app.kubernetes.io/managed-by"
+	mqManagedByVal     = "fission-console"
+)
+
+func mqSecretName(name string) string { return "sqs-mq-" + name }
+func mqDeployName(name string) string { return "mq-" + name }
+
+// ── HTTP хендлеры ────────────────────────────────────────────────────
+
+func (s *Server) handleMQTriggersRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleListMQTriggers(w, r)
+	case http.MethodPost:
+		s.handleCreateMQTrigger(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleMQTriggersAction(w http.ResponseWriter, r *http.Request) {
+	path := strings.TrimPrefix(r.URL.Path, "/console/api/mqtriggers/")
+	name := strings.Trim(path, "/")
+	if name == "" || strings.Contains(name, "/") {
+		http.NotFound(w, r)
+		return
+	}
+	switch r.Method {
+	case http.MethodDelete:
+		s.handleDeleteMQTrigger(w, r, name)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+// ── LIST ────────────────────────────────────────────────────────────
+
+func (s *Server) handleListMQTriggers(w http.ResponseWriter, r *http.Request) {
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	labelSel := fmt.Sprintf("%s=%s,%s=%s", mqManagedByLabel, mqManagedByVal, mqTriggerLabelKey, mqTriggerLabelVal)
+	deployList, err := s.kube.AppsV1().Deployments(ns).List(ctx, metav1.ListOptions{LabelSelector: labelSel})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list mq deployments: %v", err))
+		return
+	}
+
+	items := make([]map[string]any, 0, len(deployList.Items))
+	for i := range deployList.Items {
+		items = append(items, mqDeployToResponse(&deployList.Items[i]))
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"items": items})
+}
+
+// ── CREATE ──────────────────────────────────────────────────────────
+
+func (s *Server) handleCreateMQTrigger(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateMQTriggerRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "decode request: "+err.Error())
+		return
+	}
+	if err := validateMQRequest(req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+
+	endpoint := strings.TrimSpace(req.SqsEndpoint)
+	if endpoint == "" {
+		endpoint = sqsDefaultEndpoint
+	}
+	functionURL := fissionRouterBase + "/" + req.FunctionName
+	secretName := mqSecretName(req.Name)
+	deployName := mqDeployName(req.Name)
+
+	// 1. Secret с SQS credentials
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      secretName,
+			Namespace: ns,
+			Labels: map[string]string{
+				mqManagedByLabel:  mqManagedByVal,
+				mqTriggerLabelKey: mqTriggerLabelVal,
+				"mq-trigger-name": req.Name,
+			},
+		},
+		StringData: map[string]string{
+			"SQS_ACCESS_KEY": req.AccessKey,
+			"SQS_SECRET_KEY": req.SecretKey,
+			"SQS_ENDPOINT":   endpoint,
+		},
+	}
+	if _, err := s.kube.CoreV1().Secrets(ns).Create(ctx, secret, metav1.CreateOptions{}); err != nil {
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("mq trigger %q already exists", req.Name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, "create secret: "+err.Error())
+		return
+	}
+
+	// 2. Deployment (sqs-consumer)
+	replicas := int32(1)
+	deploy := &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      deployName,
+			Namespace: ns,
+			Labels: map[string]string{
+				mqManagedByLabel:  mqManagedByVal,
+				mqTriggerLabelKey: mqTriggerLabelVal,
+				"mq-trigger-name": req.Name,
+			},
+			Annotations: map[string]string{
+				"fission-console/mq-trigger-name": req.Name,
+				"fission-console/function":        req.FunctionName,
+				"fission-console/queue":           req.Queue,
+				"fission-console/sqs-endpoint":    endpoint,
+			},
+		},
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &replicas,
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{"mq-trigger-name": req.Name},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"mq-trigger-name": req.Name,
+						mqTriggerLabelKey: mqTriggerLabelVal,
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{{
+						Name:            "sqs-consumer",
+						Image:           sqsConsumerImage,
+						ImagePullPolicy: corev1.PullAlways,
+						Env: []corev1.EnvVar{
+							{Name: "SQS_QUEUE_NAME", Value: req.Queue},
+							{Name: "SQS_REGION", Value: "us-east-1"},
+							{Name: "FUNCTION_URL", Value: functionURL},
+							{Name: "POLL_INTERVAL", Value: "5"},
+							{Name: "MAX_MESSAGES", Value: "1"},
+							{Name: "MAX_RETRIES", Value: "3"},
+						},
+						EnvFrom: []corev1.EnvFromSource{{
+							SecretRef: &corev1.SecretEnvSource{
+								LocalObjectReference: corev1.LocalObjectReference{Name: secretName},
+							},
+						}},
+						Resources: corev1.ResourceRequirements{
+							Limits: corev1.ResourceList{
+								corev1.ResourceCPU:    resource.MustParse("50m"),
+								corev1.ResourceMemory: resource.MustParse("32Mi"),
+							},
+							Requests: corev1.ResourceList{
+								corev1.ResourceCPU:    resource.MustParse("10m"),
+								corev1.ResourceMemory: resource.MustParse("16Mi"),
+							},
+						},
+					}},
+				},
+			},
+		},
+	}
+
+	created, err := s.kube.AppsV1().Deployments(ns).Create(ctx, deploy, metav1.CreateOptions{})
+	if err != nil {
+		_ = s.kube.CoreV1().Secrets(ns).Delete(ctx, secretName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, "create deployment: "+err.Error())
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, mqDeployToResponse(created))
+}
+
+// ── DELETE ──────────────────────────────────────────────────────────
+
+func (s *Server) handleDeleteMQTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	dErr := s.kube.AppsV1().Deployments(ns).Delete(ctx, mqDeployName(name), metav1.DeleteOptions{})
+	sErr := s.kube.CoreV1().Secrets(ns).Delete(ctx, mqSecretName(name), metav1.DeleteOptions{})
+
+	if dErr != nil && !apierrors.IsNotFound(dErr) {
+		writeJSONError(w, http.StatusBadGateway, "delete deployment: "+dErr.Error())
+		return
+	}
+	if sErr != nil && !apierrors.IsNotFound(sErr) {
+		writeJSONError(w, http.StatusBadGateway, "delete secret: "+sErr.Error())
+		return
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name})
+}
+
+// ── Вспомогательные ─────────────────────────────────────────────────
+
+func validateMQRequest(req model.CreateMQTriggerRequest) error {
+	if strings.TrimSpace(req.Name) == "" {
+		return fmt.Errorf("name is required")
+	}
+	if strings.TrimSpace(req.FunctionName) == "" {
+		return fmt.Errorf("functionName is required")
+	}
+	if strings.TrimSpace(req.Queue) == "" {
+		return fmt.Errorf("queue is required")
+	}
+	if strings.TrimSpace(req.AccessKey) == "" {
+		return fmt.Errorf("accessKey is required")
+	}
+	if strings.TrimSpace(req.SecretKey) == "" {
+		return fmt.Errorf("secretKey is required")
+	}
+	return nil
+}
+
+func mqDeployToResponse(d *appsv1.Deployment) map[string]any {
+	ann := d.Annotations
+	if ann == nil {
+		ann = map[string]string{}
+	}
+	triggerName := ann["fission-console/mq-trigger-name"]
+	if triggerName == "" {
+		triggerName = strings.TrimPrefix(d.Name, "mq-")
+	}
+	return map[string]any{
+		"name":         triggerName,
+		"deployName":   d.Name,
+		"functionName": ann["fission-console/function"],
+		"queue":        ann["fission-console/queue"],
+		"sqsEndpoint":  ann["fission-console/sqs-endpoint"],
+		"ready":        d.Status.ReadyReplicas > 0,
+		"replicas":     d.Status.ReadyReplicas,
+	}
+}

console/internal/api/server.go

@@ -13,8 +13,10 @@ import (
 	"time"
 
 	"fission-console/internal/auth"
+	"fission-console/internal/billing"
 	"fission-console/internal/cloud"
 	"fission-console/internal/fission"
+	"fission-console/internal/stats"
 	"fission-console/ui"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -59,6 +61,12 @@ type Server struct {
 
 	// nsManager управляет жизненным циклом пользовательских namespace-ов.
 	nsManager *cloud.NSManager
+
+	// billing — слой записи статистики вызовов. NoopStore если BILLING_DSN не задан.
+	billing billing.Store
+
+	// stats — аналитический слой (Grafana Organizations). NoopProvider если не настроен.
+	stats stats.StatsProvider
 }
 
 // Config содержит все параметры для создания Server.
@@ -76,6 +84,8 @@ type Config struct {
 	Authenticator auth.Authenticator // слой аутентификации
 	LLMUrl        string
 	LLMKey        string
+	Billing       billing.Store       // слой статистики (NoopStore если не задан)
+	Stats         stats.StatsProvider // аналитика (NoopProvider если не настроен)
 }
 
 // NewServer создаёт и настраивает HTTP Server со всеми зависимостями.
@@ -96,6 +106,8 @@ func NewServer(cfg Config) *Server {
 		llmURL:        cfg.LLMUrl,
 		llmKey:        cfg.LLMKey,
 		nsManager:     cloud.NewNSManager(cfg.Dyn),
+		billing:       cfg.Billing,
+		stats:         cfg.Stats,
 	}
 }
 
@@ -157,8 +169,13 @@ func (s *Server) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("/console/api/httptriggers", auth(s.handleList(fission.HTTPTrigGVR)))
 	mux.HandleFunc("/console/api/timetriggers", auth(s.handleTimeTriggersRoot))
 	mux.HandleFunc("/console/api/timetriggers/", auth(s.handleTimeTriggersAction))
+	mux.HandleFunc("/console/api/mqtriggers", auth(s.handleMQTriggersRoot))
+	mux.HandleFunc("/console/api/mqtriggers/", auth(s.handleMQTriggersAction))
+	mux.HandleFunc("/console/api/kwtriggers", auth(s.handleKWTriggersRoot))
+	mux.HandleFunc("/console/api/kwtriggers/", auth(s.handleKWTriggersAction))
 	mux.HandleFunc("/console/api/ns/status", auth(s.handleNSStatus))
 	mux.HandleFunc("/console/api/ns/debug", auth(s.handleNSDebug))
+	mux.HandleFunc("/console/api/stats/dashboard-url", auth(s.handleStatsDashboard))
 	mux.HandleFunc("/console/api/ai/check", auth(s.handleAICheck))
 	mux.HandleFunc("/console/api/ai/lint-archive", auth(s.handleLintArchive))
 	mux.HandleFunc("/console/api/ai/explain-archive", auth(s.handleExplainArchive))

console/internal/api/stats.go

@@ -0,0 +1,25 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// handleStatsDashboard GET /console/api/stats/dashboard-url
+// Возвращает публичный URL дашборда Grafana для текущего namespace пользователя.
+// Если аналитика не настроена — возвращает {"url":""}.
+func (s *Server) handleStatsDashboard(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	ns := s.userNS(r)
+	url := s.stats.DashboardURL(r.Context(), ns)
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(map[string]any{
+		"url":       url,
+		"namespace": ns,
+	})
+}

console/internal/api/status.go

@@ -0,0 +1,138 @@
+// Package api — определение статуса функции.
+//
+// Этот файл содержит функции для определения статуса функции на основе:
+// - buildStatus пакета (Package CRD)
+// - состояния pod-а (kubernetes Pod)
+//
+// Возможные статусы:
+// - "Ready" (зелёный) — Pod в состоянии Running
+// - "Cold" (синий) — функция готова, но нет активного Pod
+// - "Building" (жёлтый) — Package ещё собирается (buildStatus != "succeeded")
+// - "Error" (красный) — Pod в состоянии ошибки (CrashLoopBackOff, ImagePullBackOff и т.д.) или build failed
+package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"fission-console/internal/fission"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// FunctionStatus — расширенный объект Function с полем status.
+type FunctionStatus struct {
+	// Встраиваем исходный объект и добавляем status
+	Object map[string]any `json:"object,inline"`
+	Status string         `json:"status"` // "Ready", "Cold", "Building", "Error"
+}
+
+// getFunctionStatus определяет статус функции на основе pod-ов и Package.
+func (s *Server) getFunctionStatus(ctx context.Context, ns string, fn *unstructured.Unstructured) (string, error) {
+	fnName := fn.GetName()
+
+	// Шаг 1: проверяем buildStatus пакета (если есть)
+	packageName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	if packageName != "" {
+		pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, packageName, metav1.GetOptions{})
+		if pkgErr == nil {
+			buildStatus, _, _ := unstructured.NestedString(pkg.Object, "status", "buildstatus")
+			// "failed" → Error
+			// "none", "succeeded" → OK, Package готов
+			// "pending", "building" и т.д. → Building
+			if buildStatus == "failed" {
+				return "Error", nil
+			}
+			if buildStatus != "" && buildStatus != "succeeded" && buildStatus != "none" {
+				// Building, Pending и т.д.
+				return "Building", nil
+			}
+		}
+	}
+
+	// Шаг 2: ищем Pod-ы для этой функции (по лейблу functionName=<name>)
+	pods, err := s.kube.CoreV1().Pods(ns).List(ctx, metav1.ListOptions{
+		LabelSelector: fmt.Sprintf("functionName=%s", fnName),
+	})
+	if err != nil && !apierrors.IsNotFound(err) {
+		// Логируем ошибку, но не падаем — возвращаем "Cold" (функция есть, но pod-а нет)
+		return "Cold", nil
+	}
+
+	// Шаг 3: анализируем состояние pod-ов
+	if pods != nil && len(pods.Items) > 0 {
+		for _, pod := range pods.Items {
+			// Проверяем фазу pod-а
+			phase := pod.Status.Phase
+			if phase == "Running" {
+				// Дополнительная проверка: все контейнеры готовы?
+				allReady := true
+				for _, status := range pod.Status.ContainerStatuses {
+					if !status.Ready {
+						allReady = false
+						break
+					}
+				}
+				if allReady {
+					return "Ready", nil
+				}
+			}
+
+			// Проверяем состояние контейнеров (CrashLoopBackOff, ImagePullBackOff и т.д.)
+			for _, status := range pod.Status.ContainerStatuses {
+				if status.State.Waiting != nil && status.State.Waiting.Reason == "CrashLoopBackOff" {
+					return "Error", nil
+				}
+				if status.State.Waiting != nil && status.State.Waiting.Reason == "ImagePullBackOff" {
+					return "Error", nil
+				}
+				if status.LastTerminationState.Terminated != nil && status.LastTerminationState.Terminated.ExitCode != 0 {
+					return "Error", nil
+				}
+			}
+		}
+
+		// Pod есть, но не в Running или Error состоянии → Building/Deploying
+		return "Building", nil
+	}
+
+	// Нет pod-ов → Cold (функция холодная, но готова)
+	return "Cold", nil
+}
+
+// handleListFunctionsWithStatus возвращает список функций с полем "status".
+// Добавляет status в поле .metadata.annotations["fission-console/status"] каждой функции.
+func (s *Server) handleListFunctionsWithStatus(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second) // 30 сек для определения статуса всех функций
+	defer cancel()
+	ns := s.userNS(r)
+
+	// Получаем список функций
+	list, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list functions: %v", err))
+		return
+	}
+
+	// Обогащаем каждую функцию статусом (добавляем в .metadata.annotations["fission-console/status"])
+	for i := range list.Items {
+		status, _ := s.getFunctionStatus(ctx, ns, &list.Items[i])
+		anns := list.Items[i].GetAnnotations()
+		if anns == nil {
+			anns = make(map[string]string)
+		}
+		anns["fission-console/status"] = status
+		list.Items[i].SetAnnotations(anns)
+	}
+
+	writeJSON(w, http.StatusOK, list.Items)
+}

console/internal/billing/billing.go

@@ -0,0 +1,42 @@
+// Package billing — слой записи статистики вызовов функций.
+//
+// Независим от типа БД: снаружи виден только интерфейс Store.
+// Если BILLING_DSN не задан — работает NoopStore (тихо, не крашит).
+package billing
+
+import "time"
+
+// TriggerType описывает источник вызова.
+const (
+	TriggerHTTP    = "http"    // вызов через /fn/... снаружи
+	TriggerCron    = "cron"    // вызов по расписанию
+	TriggerConsole = "console" // вызов через кнопку «Вызов» в UI
+	TriggerEvent   = "event"   // lifecycle: create/delete/clone/update
+)
+
+// Invocation — одна запись о вызове или событии функции.
+type Invocation struct {
+	Namespace     string    // пользовательский namespace (= пользователь)
+	FunctionName  string    // имя функции
+	TriggerType   string    // TriggerHTTP / TriggerCron / TriggerConsole / TriggerEvent
+	Route         string    // HTTP маршрут (/abc123/my-func), пусто для event
+	HTTPMethod    string    // GET/POST/... пусто для event
+	StartedAt     time.Time // время начала
+	DurationMS    int64     // длительность в миллисекундах (0 для event)
+	StatusCode    int       // HTTP статус ответа (0 для event)
+	ColdStart     bool      // true = первый вызов после создания/простоя
+	RequestBytes  int64     // размер тела запроса
+	ResponseBytes int64     // размер тела ответа
+	ErrorMsg      string    // сообщение об ошибке, пусто если успех
+	RecordedBy    string    // "console" | "router"
+	EventType     string    // для TriggerEvent: "create" | "delete" | "clone" | "update" | "invoke"
+}
+
+// Store — интерфейс записи статистики.
+// Реализации: pgStore (PostgreSQL через pgx), NoopStore (заглушка).
+type Store interface {
+	// RecordInvocation записывает одно событие асинхронно (fire-and-forget).
+	RecordInvocation(inv Invocation)
+	// Close освобождает ресурсы (пул соединений и т.д.).
+	Close()
+}

console/internal/billing/factory.go

@@ -0,0 +1,23 @@
+package billing
+
+import (
+	"context"
+	"log"
+	"os"
+)
+
+// NewStore создаёт Store из переменной окружения BILLING_DSN.
+// Если DSN пустой — возвращает NoopStore (статистика отключена, сервер работает нормально).
+func NewStore() Store {
+	dsn := os.Getenv("BILLING_DSN")
+	if dsn == "" {
+		log.Printf("billing: BILLING_DSN not set, statistics disabled")
+		return NoopStore{}
+	}
+	store, err := NewPostgresStore(context.Background(), dsn)
+	if err != nil {
+		log.Printf("billing: failed to connect to PostgreSQL: %v — statistics disabled", err)
+		return NoopStore{}
+	}
+	return store
+}

console/internal/billing/noop.go

@@ -0,0 +1,8 @@
+package billing
+
+// NoopStore — заглушка Store, которая тихо игнорирует все записи.
+// Используется когда BILLING_DSN не задан.
+type NoopStore struct{}
+
+func (NoopStore) RecordInvocation(_ Invocation) {}
+func (NoopStore) Close()                        {}

console/internal/billing/pg.go

@@ -0,0 +1,90 @@
+package billing
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// pgStore — реализация Store поверх PostgreSQL через pgx connection pool.
+type pgStore struct {
+	pool *pgxpool.Pool
+}
+
+// NewPostgresStore создаёт Store с пулом соединений к PostgreSQL.
+// dsn — строка вида postgres://user:pass@host:5432/dbname
+// При ошибке подключения — возвращает ошибку, вызывающий код решает как реагировать.
+func NewPostgresStore(ctx context.Context, dsn string) (Store, error) {
+	cfg, err := pgxpool.ParseConfig(dsn)
+	if err != nil {
+		return nil, err
+	}
+	cfg.MaxConns = 4
+	cfg.MinConns = 1
+	cfg.MaxConnIdleTime = 5 * time.Minute
+
+	pool, err := pgxpool.NewWithConfig(ctx, cfg)
+	if err != nil {
+		return nil, err
+	}
+	// Проверяем живость соединения
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, err
+	}
+	log.Printf("billing: connected to PostgreSQL")
+	return &pgStore{pool: pool}, nil
+}
+
+// RecordInvocation вставляет запись асинхронно — не блокирует основной поток.
+func (s *pgStore) RecordInvocation(inv Invocation) {
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		_, err := s.pool.Exec(ctx, `
+			INSERT INTO invocations (
+				namespace, function_name, trigger_type, route, http_method,
+				started_at, duration_ms, status_code, cold_start,
+				request_bytes, response_bytes, error_msg, recorded_by, event_type
+			) VALUES (
+				$1,$2,$3,$4,$5,
+				$6,$7,$8,$9,
+				$10,$11,$12,$13,$14
+			)`,
+			inv.Namespace,
+			inv.FunctionName,
+			inv.TriggerType,
+			inv.Route,
+			inv.HTTPMethod,
+			inv.StartedAt,
+			inv.DurationMS,
+			inv.StatusCode,
+			inv.ColdStart,
+			inv.RequestBytes,
+			inv.ResponseBytes,
+			nullIfEmpty(inv.ErrorMsg),
+			inv.RecordedBy,
+			nullIfEmpty(inv.EventType),
+		)
+		if err != nil {
+			log.Printf("billing: insert invocation: %v", err)
+		}
+	}()
+}
+
+// Close закрывает пул соединений.
+func (s *pgStore) Close() {
+	s.pool.Close()
+	log.Printf("billing: connection pool closed")
+}
+
+// nullIfEmpty возвращает nil для пустой строки (SQL NULL вместо пустой строки).
+func nullIfEmpty(s string) interface{} {
+	if s == "" {
+		return nil
+	}
+	return s
+}

console/internal/fission/client.go

@@ -12,6 +12,8 @@ var (
 	FunctionGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "functions"}
 	HTTPTrigGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "httptriggers"}
 	TimeTrigGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "timetriggers"}
+	MQTrigGVR      = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "messagequeuetriggers"}
+	KWTrigGVR      = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "kuberneteswatchtriggers"}
 
 	NamespaceGVR  = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
 	DeploymentGVR = schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}

console/internal/model/types.go

@@ -26,6 +26,28 @@ type CreateTimeTriggerRequest struct {
 	SubPath      string `json:"subpath"`
 }
 
+// CreateMQTriggerRequest — тело POST /console/api/mqtriggers.
+// Архитектура: Console создаёт K8s Deployment (sqs-consumer) + Secret с credentials
+// в namespace пользователя. sqs-consumer поллит shared-sqs → вызывает Fission-функцию.
+type CreateMQTriggerRequest struct {
+	Name         string `json:"name"`
+	FunctionName string `json:"functionName"`
+	Queue        string `json:"queue"`       // имя очереди в SQS
+	SqsEndpoint  string `json:"sqsEndpoint"` // URL SQS сервиса (default: internal shared-sqs)
+	AccessKey    string `json:"accessKey"`   // SQS access key тенанта
+	SecretKey    string `json:"secretKey"`   // SQS secret key тенанта
+}
+
+// CreateKWTriggerRequest — тело POST /console/api/kwtriggers.
+// Документация полей: kubectl get crd kuberneteswatchtriggers.fission.io -o json
+type CreateKWTriggerRequest struct {
+	Name          string `json:"name"`
+	FunctionName  string `json:"functionName"`
+	ResourceType  string `json:"resourceType"`  // Pod, Service, Deployment и т.д.
+	Namespace     string `json:"namespace"`     // пустое = namespace пользователя
+	LabelSelector string `json:"labelSelector"` // "app=foo" или "" для всех
+}
+
 // UpdateCodeRequest — тело PUT /console/api/functions/:name/code.
 type UpdateCodeRequest struct {
 	Code    string `json:"code"`

console/internal/stats/factory.go

@@ -0,0 +1,36 @@
+package stats
+
+import (
+	"log"
+	"os"
+	"strings"
+)
+
+// NewProvider создаёт StatsProvider из переменных окружения.
+//
+// Переменные:
+//   - GRAFANA_INTERNAL_URL — внутренний URL (http://grafana.grafana.svc.cluster.local:3000)
+//   - GRAFANA_PUBLIC_URL   — публичный URL для ссылок (https://fission.kube5s.ru/grafana)
+//   - GRAFANA_ADMIN_USER   — имя admin (default: "admin")
+//   - GRAFANA_ADMIN_PASS   — пароль admin
+func NewProvider() StatsProvider {
+	internalURL := strings.TrimSpace(os.Getenv("GRAFANA_INTERNAL_URL"))
+	if internalURL == "" {
+		log.Printf("stats: GRAFANA_INTERNAL_URL not set — using NoopProvider")
+		return NoopProvider{}
+	}
+
+	publicURL := strings.TrimSpace(os.Getenv("GRAFANA_PUBLIC_URL"))
+	if publicURL == "" {
+		publicURL = "https://fission.kube5s.ru/grafana"
+	}
+
+	adminUser := strings.TrimSpace(os.Getenv("GRAFANA_ADMIN_USER"))
+	if adminUser == "" {
+		adminUser = "admin"
+	}
+	adminPass := os.Getenv("GRAFANA_ADMIN_PASS")
+
+	log.Printf("stats: GrafanaProvider internalURL=%s publicURL=%s user=%s", internalURL, publicURL, adminUser)
+	return NewGrafanaProvider(internalURL, publicURL, adminUser, adminPass)
+}

console/internal/stats/grafana.go

@@ -0,0 +1,382 @@
+package stats
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// GrafanaProvider реализует StatsProvider через Grafana HTTP API.
+//
+// Для каждого namespace создаётся изолированная Grafana Organization:
+//   - PostgreSQL datasource (тот же DSN, uid="fission-user-pg")
+//   - Dashboard с hardcoded WHERE namespace='...'
+//   - Public Dashboard (без логина) → accessToken
+//
+// Потокобезопасен: sync.RWMutex + per-namespace singleflight.
+type GrafanaProvider struct {
+	internalURL string // http://grafana.grafana.svc.cluster.local:3000
+	publicURL   string // https://fission.kube5s.ru/grafana
+	adminUser   string
+	adminPass   string
+	http        *http.Client
+
+	mu     sync.RWMutex
+	tokens map[string]string // namespace → publicDashboardAccessToken
+	orgIDs map[string]int64  // namespace → grafana orgId
+}
+
+// NewGrafanaProvider создаёт GrafanaProvider.
+func NewGrafanaProvider(internalURL, publicURL, adminUser, adminPass string) *GrafanaProvider {
+	return &GrafanaProvider{
+		internalURL: strings.TrimRight(internalURL, "/"),
+		publicURL:   strings.TrimRight(publicURL, "/"),
+		adminUser:   adminUser,
+		adminPass:   adminPass,
+		http:        &http.Client{Timeout: 20 * time.Second},
+		tokens:      make(map[string]string),
+		orgIDs:      make(map[string]int64),
+	}
+}
+
+// EnsureOrgForNamespace идемпотентно создаёт Grafana Org + datasource + dashboard + public link.
+func (g *GrafanaProvider) EnsureOrgForNamespace(ctx context.Context, namespace, email string) error {
+	// Быстрый путь: уже провизировано в этом процессе
+	g.mu.RLock()
+	_, cached := g.tokens[namespace]
+	g.mu.RUnlock()
+	if cached {
+		return nil
+	}
+
+	// Шаг 1: получить или создать Org
+	orgID, err := g.getOrCreateOrg(ctx, namespace)
+	if err != nil {
+		return fmt.Errorf("getOrCreateOrg(%s): %w", namespace, err)
+	}
+
+	// Шаг 2: создать datasource в этой Org (идемпотентно)
+	if err := g.ensureDatasource(ctx, orgID); err != nil {
+		log.Printf("stats: ensureDatasource org=%d ns=%s: %v", orgID, namespace, err)
+		// не фатально — dashboard может не работать но org создана
+	}
+
+	// Шаг 3: создать dashboard с hardcoded namespace (идемпотентно)
+	dashUID, err := g.ensureDashboard(ctx, orgID, namespace)
+	if err != nil {
+		return fmt.Errorf("ensureDashboard org=%d ns=%s: %w", orgID, namespace, err)
+	}
+
+	// Шаг 4: получить или создать public dashboard → accessToken
+	token, err := g.ensurePublicDashboard(ctx, orgID, dashUID)
+	if err != nil {
+		return fmt.Errorf("ensurePublicDashboard org=%d dash=%s: %w", orgID, dashUID, err)
+	}
+
+	// Кэшируем
+	g.mu.Lock()
+	g.tokens[namespace] = token
+	g.orgIDs[namespace] = orgID
+	g.mu.Unlock()
+
+	log.Printf("stats: org provisioned ns=%s orgId=%d publicToken=%s...", namespace, orgID, token[:8])
+	return nil
+}
+
+// DashboardURL возвращает публичный URL или "" если ещё не провизировано.
+func (g *GrafanaProvider) DashboardURL(ctx context.Context, namespace string) string {
+	// Сначала пробуем из кэша
+	g.mu.RLock()
+	token, ok := g.tokens[namespace]
+	g.mu.RUnlock()
+	if ok && token != "" {
+		return g.publicURL + "/public-dashboards/" + token
+	}
+
+	// Кэш промах (после перезапуска сервера) — провизируем заново
+	if err := g.EnsureOrgForNamespace(ctx, namespace, ""); err != nil {
+		log.Printf("stats: DashboardURL re-provision ns=%s: %v", namespace, err)
+		return ""
+	}
+
+	g.mu.RLock()
+	token = g.tokens[namespace]
+	g.mu.RUnlock()
+	if token == "" {
+		return ""
+	}
+	return g.publicURL + "/public-dashboards/" + token
+}
+
+// --- Grafana API helpers ---
+
+// getOrCreateOrg возвращает orgId существующей или создаёт новую Org.
+func (g *GrafanaProvider) getOrCreateOrg(ctx context.Context, namespace string) (int64, error) {
+	// Проверяем кэш orgIDs
+	g.mu.RLock()
+	if id, ok := g.orgIDs[namespace]; ok {
+		g.mu.RUnlock()
+		return id, nil
+	}
+	g.mu.RUnlock()
+
+	// GET /api/orgs/name/{namespace}
+	resp, body, err := g.grafanaRequest(ctx, http.MethodGet, "/api/orgs/name/"+namespace, 0, nil)
+	if err != nil {
+		return 0, err
+	}
+	if resp.StatusCode == http.StatusOK {
+		var org struct {
+			ID int64 `json:"id"`
+		}
+		if err := json.Unmarshal(body, &org); err != nil {
+			return 0, fmt.Errorf("parse org: %w", err)
+		}
+		return org.ID, nil
+	}
+
+	// Org не найдена — создаём
+	payload := map[string]string{"name": namespace}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, "/api/orgs", 0, payload)
+	if err != nil {
+		return 0, err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return 0, fmt.Errorf("create org status=%d body=%s", resp.StatusCode, string(body))
+	}
+	var created struct {
+		OrgID int64 `json:"orgId"`
+	}
+	if err := json.Unmarshal(body, &created); err != nil {
+		return 0, fmt.Errorf("parse create org: %w", err)
+	}
+	return created.OrgID, nil
+}
+
+// ensureDatasource создаёт PostgreSQL datasource в org (uid="fission-user-pg").
+// Идемпотентен: 409 Conflict считается успехом.
+func (g *GrafanaProvider) ensureDatasource(ctx context.Context, orgID int64) error {
+	// Проверяем есть ли уже datasource в этой org
+	resp, _, err := g.grafanaRequest(ctx, http.MethodGet, "/api/datasources/uid/fission-user-pg", orgID, nil)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode == http.StatusOK {
+		return nil // уже есть
+	}
+
+	// Получаем DSN из уже существующего datasource в Org 1 (uid=fission-pg)
+	_, body, err := g.grafanaRequest(ctx, http.MethodGet, "/api/datasources/uid/fission-pg", 1, nil)
+	if err != nil {
+		return fmt.Errorf("get main datasource: %w", err)
+	}
+	var ds struct {
+		URL            string          `json:"url"`
+		JSONData       json.RawMessage `json:"jsonData"`
+		SecureJSONData struct {
+			Password string `json:"password"`
+		} `json:"secureJsonData"`
+	}
+	if err := json.Unmarshal(body, &ds); err != nil {
+		return fmt.Errorf("parse main datasource: %w", err)
+	}
+
+	// Создаём копию datasource в новой Org
+	payload := map[string]any{
+		"name":   "fission-pg",
+		"type":   "postgres",
+		"uid":    "fission-user-pg",
+		"url":    ds.URL,
+		"access": "proxy",
+		"jsonData": map[string]any{
+			"sslmode":         "disable",
+			"postgresVersion": 1700,
+			"timescaledb":     false,
+		},
+		"secureJsonData": ds.SecureJSONData,
+	}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, "/api/datasources", orgID, payload)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode == http.StatusConflict {
+		return nil // уже существует
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return fmt.Errorf("create datasource status=%d body=%s", resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+// ensureDashboard создаёт/обновляет user-дашборд в org.
+// Возвращает uid дашборда.
+func (g *GrafanaProvider) ensureDashboard(ctx context.Context, orgID int64, namespace string) (string, error) {
+	const dashUID = "fission-user-overview"
+
+	// Проверяем существование
+	resp, _, err := g.grafanaRequest(ctx, http.MethodGet, "/api/dashboards/uid/"+dashUID, orgID, nil)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode == http.StatusOK {
+		return dashUID, nil // уже есть
+	}
+
+	// Импортируем dashboard JSON с hardcoded namespace
+	dashJSON := userDashboardJSON(namespace)
+	payload := map[string]any{
+		"dashboard": json.RawMessage(dashJSON),
+		"overwrite": true,
+		"folderId":  0,
+	}
+	resp, body, err := g.grafanaRequest(ctx, http.MethodPost, "/api/dashboards/db", orgID, payload)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("import dashboard status=%d body=%s", resp.StatusCode, string(body))
+	}
+	return dashUID, nil
+}
+
+// ensurePublicDashboard создаёт public dashboard и возвращает accessToken.
+// Идемпотентен: если уже существует — возвращает существующий token.
+func (g *GrafanaProvider) ensurePublicDashboard(ctx context.Context, orgID int64, dashUID string) (string, error) {
+	path := "/api/dashboards/uid/" + dashUID + "/public-dashboards"
+
+	// Проверяем существование
+	resp, body, err := g.grafanaRequest(ctx, http.MethodGet, path, orgID, nil)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode == http.StatusOK {
+		var pd struct {
+			AccessToken string `json:"accessToken"`
+		}
+		if err := json.Unmarshal(body, &pd); err != nil {
+			return "", fmt.Errorf("parse public dashboard: %w", err)
+		}
+		if pd.AccessToken != "" {
+			return pd.AccessToken, nil
+		}
+	}
+
+	// Создаём
+	payload := map[string]any{
+		"isEnabled":            true,
+		"annotationsEnabled":   false,
+		"timeSelectionEnabled": true,
+	}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, path, orgID, payload)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("create public dashboard status=%d body=%s", resp.StatusCode, string(body))
+	}
+
+	var pd struct {
+		AccessToken string `json:"accessToken"`
+	}
+	if err := json.Unmarshal(body, &pd); err != nil {
+		return "", fmt.Errorf("parse created public dashboard: %w", err)
+	}
+	if pd.AccessToken == "" {
+		return "", fmt.Errorf("empty accessToken in response: %s", string(body))
+	}
+	return pd.AccessToken, nil
+}
+
+// grafanaRequest выполняет HTTP запрос к Grafana API.
+// orgID > 0 → устанавливает X-Grafana-Org-Id заголовок (thread-safe, без смены контекста).
+// orgID == 0 → без заголовка (используется Org 1 admin по умолчанию).
+func (g *GrafanaProvider) grafanaRequest(ctx context.Context, method, path string, orgID int64, payload any) (*http.Response, []byte, error) {
+	var bodyReader io.Reader
+	if payload != nil {
+		data, err := json.Marshal(payload)
+		if err != nil {
+			return nil, nil, fmt.Errorf("marshal payload: %w", err)
+		}
+		bodyReader = bytes.NewReader(data)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, g.internalURL+path, bodyReader)
+	if err != nil {
+		return nil, nil, fmt.Errorf("new request: %w", err)
+	}
+	req.SetBasicAuth(g.adminUser, g.adminPass)
+	if payload != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	if orgID > 0 {
+		req.Header.Set("X-Grafana-Org-Id", fmt.Sprintf("%d", orgID))
+	}
+
+	resp, err := g.http.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("do request %s %s: %w", method, path, err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp, nil, fmt.Errorf("read body: %w", err)
+	}
+	return resp, body, nil
+}
+
+// userDashboardJSON генерирует JSON дашборда для конкретного namespace.
+// Namespace вшит прямо в SQL запросы — без template variables.
+// Dashboard uid="fission-user-overview" (per-org, без конфликтов между org).
+func userDashboardJSON(namespace string) string {
+	// Безопасное экранирование namespace для SQL (namespace это sha256 hex — только [a-z0-9-])
+	ns := strings.ReplaceAll(namespace, "'", "''")
+	return fmt.Sprintf(`{
+  "title": "Мои функции — %s",
+  "uid": "fission-user-overview",
+  "tags": ["fission", "user"],
+  "timezone": "browser",
+  "refresh": "1m",
+  "time": {"from": "now-24h", "to": "now"},
+  "panels": [
+    {
+      "id": 1, "title": "Вызовы в час", "type": "timeseries",
+      "gridPos": {"x": 0, "y": 0, "w": 16, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT date_trunc('hour', started_at) AS time, count(*) AS value, function_name FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1, function_name ORDER BY 1", "format": "time_series", "refId": "A"}]
+    },
+    {
+      "id": 2, "title": "Успех vs Ошибки", "type": "piechart",
+      "gridPos": {"x": 16, "y": 0, "w": 8, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT CASE WHEN status_code >= 200 AND status_code < 300 THEN 'success' WHEN status_code = 0 THEN 'event' ELSE 'error' END AS metric, count(*) AS value FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1", "format": "table", "refId": "A"}]
+    },
+    {
+      "id": 3, "title": "Топ функций", "type": "bargauge",
+      "gridPos": {"x": 0, "y": 8, "w": 12, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT function_name AS metric, count(*) AS value FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1 ORDER BY 2 DESC LIMIT 10", "format": "table", "refId": "A"}]
+    },
+    {
+      "id": 4, "title": "Средняя латентность (ms)", "type": "timeseries",
+      "gridPos": {"x": 12, "y": 8, "w": 12, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT date_trunc('hour', started_at) AS time, round(avg(duration_ms)) AS avg_ms FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() AND trigger_type != 'event' GROUP BY 1 ORDER BY 1", "format": "time_series", "refId": "A"}]
+    },
+    {
+      "id": 5, "title": "Последние события", "type": "table",
+      "gridPos": {"x": 0, "y": 16, "w": 24, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT started_at AS time, function_name, trigger_type, event_type, status_code, duration_ms, error_msg FROM invocations WHERE namespace = '%s' ORDER BY started_at DESC LIMIT 50", "format": "table", "refId": "A"}]
+    }
+  ],
+  "schemaVersion": 39
+}`, namespace, ns, ns, ns, ns, ns)
+}

console/internal/stats/noop.go

@@ -0,0 +1,10 @@
+package stats
+
+import "context"
+
+// NoopProvider — заглушка когда GRAFANA_INTERNAL_URL не задан.
+// Ни на что не влияет, не крашит.
+type NoopProvider struct{}
+
+func (NoopProvider) EnsureOrgForNamespace(_ context.Context, _, _ string) error { return nil }
+func (NoopProvider) DashboardURL(_ context.Context, _ string) string            { return "" }

console/internal/stats/provider.go

@@ -0,0 +1,20 @@
+// Package stats — аналитический слой консоли.
+//
+// StatsProvider абстрагирует конкретный инструмент (Grafana, Prometheus, etc.).
+// При смене инструмента достаточно заменить реализацию и переменные окружения.
+package stats
+
+import "context"
+
+// StatsProvider — интерфейс аналитики.
+// Реализации: GrafanaProvider (GRAFANA_INTERNAL_URL задан), NoopProvider (заглушка).
+type StatsProvider interface {
+	// EnsureOrgForNamespace идемпотентно создаёт аналитическое пространство
+	// для namespace (Grafana Org + datasource + dashboard + public link).
+	// Вызывается при handleAuth — fire-and-forget горутиной.
+	EnsureOrgForNamespace(ctx context.Context, namespace, email string) error
+
+	// DashboardURL возвращает публичный URL дашборда без логина.
+	// Возвращает "" если аналитика не настроена или provisioning не завершён.
+	DashboardURL(ctx context.Context, namespace string) string
+}

console/ui/index.html

@@ -25,6 +25,7 @@
   <script src="js/fn-archive.js"></script>
   <script src="js/ai.js"></script>
   <script src="js/app.js"></script>
+  <script src="js/mq.js"></script>
 </head>
 
 <body>
@@ -102,13 +103,14 @@
       <div class="nubes">NUBES</div>
       <div class="product">FISSION CONSOLE</div>
     </div>
-    <div style="font-size:0.65rem; color:var(--text-secondary); margin-left:10px; align-self:center; opacity:0.7;">v1.3.69</div>
+    <div style="font-size:0.65rem; color:var(--text-secondary); margin-left:10px; align-self:center; opacity:0.7;">v1.3.88</div>
   </div>
   <div class="row" style="margin:0;">
     <button class="btn ghost" onclick="reloadAll()">Refresh</button>
     <button class="btn" onclick="openCreateCode()">✏️ Из кода</button>
     <button class="btn" onclick="openCreateArchive()">📦 Из архива</button>
     <button class="btn ghost" onclick="openHelp()">Help</button>
+    <button class="btn ghost" onclick="openAnalytics()" title="Открыть дашборд Grafana">📊 Аналитика</button>
     <button class="btn ghost" onclick="doLogout()" style="margin-left:8px;">Выход</button>
   </div>
   </div>
@@ -135,6 +137,10 @@
         <div class="k">Крон-функции</div>
         <div id="cron-count" class="v">-</div>
       </div>
+      <div class="card">
+        <div class="k">MQ-триггеры</div>
+        <div id="mq-count" class="v">-</div>
+      </div>
     </div>
 
     <div class="box">
@@ -142,10 +148,23 @@
         <div style="font-weight:600;">Функции</div>
         <div class="hint">Actions: view, edit code, invoke, delete</div>
       </div>
+      
+      <!-- Легенда статусов -->
+      <div style="margin-bottom:12px; padding:8px; background:var(--bg-alt); border-radius:4px; font-size:0.9em; color:var(--text-secondary);">
+        <strong>Статусы функций:</strong>
+        <span style="margin-left:16px;">
+          <span style="display:inline-block; width:10px; height:10px; border-radius:50%; background:#2a2; vertical-align:middle;"></span> Готова
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#22a; vertical-align:middle;"></span> Холодная
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#aa2; vertical-align:middle;"></span> Сборка
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#a22; vertical-align:middle;"></span> Ошибка
+        </span>
+      </div>
+      
       <table>
         <thead>
           <tr>
             <th>Имя</th>
+            <th title="Статус функции (Готова / Холодная / Сборка / Ошибка)">Статус</th>
             <th title="Тип источника функции">Тип</th>
             <th>Создана</th>
             <th>Изменена</th>
@@ -160,6 +179,72 @@
       <div id="status" class="status"></div>
       <div class="hint">Изменения применяются напрямую через CRD Fission.</div>
     </div>
+
+    <!-- MQ-триггеры -->
+    <div class="box">
+      <div class="toolbar">
+        <div style="font-weight:600;">MQ-триггеры</div>
+        <button class="btn" onclick="openCreateMQ()">+ Добавить</button>
+      </div>
+      <table>
+        <thead>
+          <tr>
+            <th>Имя</th>
+            <th>Очередь</th>
+            <th>Функция</th>
+            <th>Endpoint SQS</th>
+            <th>Статус</th>
+            <th>Действия</th>
+          </tr>
+        </thead>
+        <tbody id="mq-rows">
+          <tr><td colspan="6" style="color:var(--fg-muted,#888);text-align:center;">Загрузка...</td></tr>
+        </tbody>
+      </table>
+      <div class="hint">MQ-триггер поллит очередь SQS и вызывает Fission-функцию при появлении сообщений.</div>
+    </div>
+  </div>
+
+  <!-- Модалка: создать MQ-триггер -->
+  <div id="mq-create-modal" class="modal">
+    <div class="panel" style="width:520px;max-width:96vw;">
+      <h3>📨 Создать MQ-триггер</h3>
+      <div class="row">
+        <div class="field">
+          <label>Имя триггера</label>
+          <input id="mq-name" placeholder="weather-trigger">
+        </div>
+        <div class="field">
+          <label>Функция</label>
+          <input id="mq-fn" placeholder="weather-store">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Имя очереди (SQS)</label>
+          <input id="mq-queue" placeholder="weather-raw">
+        </div>
+        <div class="field">
+          <label>SQS Endpoint</label>
+          <input id="mq-endpoint" placeholder="http://shared-sqs.shared-sqs.svc.cluster.local:4100">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Access Key</label>
+          <input id="mq-access-key" placeholder="SSAK-...">
+        </div>
+        <div class="field">
+          <label>Secret Key</label>
+          <input id="mq-secret-key" type="password" placeholder="...">
+        </div>
+      </div>
+      <div id="mq-create-error" class="modal-error"></div>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeMQCreate()">Отмена</button>
+        <button class="btn" onclick="submitCreateMQ()">Создать</button>
+      </div>
+    </div>
   </div>
 
   <!-- Модалка: создать функцию из кода (prefix cc-) -->
@@ -376,7 +461,31 @@
           style="display:none;margin-top:8px;padding:10px 12px;border-radius:6px;font-size:13px;line-height:1.5;white-space:pre-wrap;font-family:monospace;">
         </div>
       </div>
+
+      <!-- Переменные окружения -->
+      <div style="margin-top:16px;">
+        <div style="font-weight:600; margin-bottom:8px; font-size:13px;">Переменные окружения</div>
+        <div id="e-tf-env-warn" style="display:none; margin-bottom:8px; padding:6px 10px; background:#553300; color:#ffa; border-radius:4px; font-size:12px;">
+          ⚠️ Функция управляется Terraform — переменные только для чтения
+        </div>
+        <div id="e-envvars-list" style="display:flex; flex-direction:column; gap:4px; margin-bottom:8px;"></div>
+        <button id="e-add-envvar-btn" class="btn ghost" style="font-size:12px;" onclick="addEnvVarRow('e')">+ Добавить переменную</button>
+      </div>
+
+      <div id="e-error-msg" style="display:none;color:#f66;font-size:0.85rem;margin-bottom:8px;"></div>
+
+      <div id="e-clone-area" style="display:none;margin-top:10px;padding:10px 12px;background:var(--bg-alt,#2a2a3a);border-radius:6px;border:1px solid var(--border,#444);">
+        <div style="font-size:0.82rem;color:var(--fg-muted,#aaa);margin-bottom:6px;">Имя новой функции (копии):</div>
+        <div style="display:flex;gap:8px;align-items:center;">
+          <input id="e-clone-name" placeholder="new-function-name" style="flex:1;font-size:0.85rem;">
+          <button class="btn" onclick="submitClone()">Клонировать</button>
+          <button class="btn ghost" onclick="toggleCloneArea(false)">✕</button>
+        </div>
+        <div id="e-clone-error" style="display:none;color:#f66;font-size:0.78rem;margin-top:5px;"></div>
+      </div>
+
       <div class="actions">
+        <button class="btn ghost" onclick="toggleCloneArea(true)" title="Создать копию функции">📋 Клон</button>
         <button class="btn ghost" onclick="closeEdit()">Отмена</button>
         <button id="e-submit" class="btn" onclick="submitEdit()">Сохранить</button>
       </div>
@@ -440,6 +549,26 @@
         </div>
       </div>
 
+      <div class="help-section">
+        <h4>Переменные окружения функции</h4>
+        <div class="help-list">
+          <div>В редакторе функции (кнопка <strong>Ред.</strong>) есть раздел <strong>Переменные окружения</strong>.</div>
+          <div>Нажмите <strong>+ Добавить</strong> чтобы задать переменную: введите имя и значение, нажмите <strong>Сохранить env vars</strong>.</div>
+          <div>Переменные доступны внутри функции через <span class="mono">os.environ</span> (Python), <span class="mono">process.env</span> (Node.js), <span class="mono">os.Getenv</span> (Go) и т.д.</div>
+          <div>Изменения применяются к запущенному поду функции сразу после сохранения.</div>
+        </div>
+      </div>
+
+      <div class="help-section">
+        <h4>Клонирование функции</h4>
+        <div class="help-list">
+          <div>В редакторе функции (кнопка <strong>Ред.</strong>) есть кнопка <strong>📋 Клон</strong> в нижней панели.</div>
+          <div>Введите имя для новой функции и нажмите <strong>Клонировать</strong>.</div>
+          <div>Клон получает тот же код, язык, entrypoint, timeout и env vars. Маршрут назначается автоматически.</div>
+          <div>Имя: строчные буквы, цифры, дефис; не начинается и не заканчивается дефисом; до 57 символов.</div>
+        </div>
+      </div>
+
       <div class="help-section">
         <h4>Как вызвать функцию вне веб-интерфейса</h4>
         <div class="help-list">
@@ -485,7 +614,7 @@
       </div>
 
       <div class="actions" style="justify-content:space-between; align-items:center;">
-        <span style="font-size:0.75rem; color:var(--text-secondary);">v1.3.69</span>
+        <span style="font-size:0.75rem; color:var(--text-secondary);">v1.3.88</span>
         <button class="btn ghost" onclick="closeHelp()">Закрыть</button>
       </div>
     </div>

console/ui/js/app.js

@@ -16,6 +16,9 @@ async function reloadAll() {
       getJSON(API_BASE + '/timetriggers')
     ]);
 
+    // MQ-триггеры загружаем параллельно, не блокируем основную таблицу
+    if (typeof loadMQTriggers === 'function') loadMQTriggers();
+
     S.envs = envs || [];
     S.fns = fns || [];
     S.httpTriggers = http || [];
@@ -48,6 +51,20 @@ async function reloadAll() {
       const createdAt = ann['fission-console/created-at'] || meta.creationTimestamp || '-';
       const updatedAt = ann['fission-console/updated-at'] || createdAt;
       const sourceType = ann['fission-console/source-type'] || 'code';
+      const status = ann['fission-console/status'] || 'Cold';
+      
+      // Статус функции: иконка и цвет
+      const statusColor = {
+        'Ready': '#2a2', 'Cold': '#22a', 'Building': '#aa2', 'Error': '#a22'
+      }[status] || '#666';
+      const statusTitle = {
+        'Ready': 'Готова (есть pod)', 
+        'Cold': 'Холодная (pod создаётся при первом вызове)',
+        'Building': 'Собирается / деплоится',
+        'Error': 'Ошибка (pod в CrashLoopBackOff или build failed)'
+      }[status] || 'Неизвестно';
+      const statusDot = '<span style="display:inline-block; width:12px; height:12px; border-radius:50%; background:' + statusColor + '; cursor:default;" title="' + h(statusTitle) + '"></span>';
+      
       const sourceIcon = sourceType === 'archive'
         ? '<span title="Из архива (.zip)" style="font-size:1.1em; cursor:default;">📦</span>'
         : '<span title="Из кода (редактор)" style="font-size:1.1em; cursor:default;">📝</span>';
@@ -58,7 +75,7 @@ async function reloadAll() {
       var infoData = h(JSON.stringify({
         name: name, env: env, pkg: pkg, entrypoint: entrypoint, timeout: timeout,
         route: route, methods: methods, sourceType: sourceType,
-        createdAt: createdAt, updatedAt: updatedAt, cron: cron
+        createdAt: createdAt, updatedAt: updatedAt, cron: cron, status: status
       }));
       var actions = tfBadge +
         '<button class="btn ghost" onclick="openInfo(\'' + h(name) + '\', this)" data-info="' + infoData + '">Info</button> ' +
@@ -68,6 +85,7 @@ async function reloadAll() {
         '<button class="btn danger" onclick="removeFn(\'' + h(name) + '\')">Удалить</button>';
       return '<tr>' +
         '<td class="mono">' + h(name) + '</td>' +
+        '<td style="text-align:center;">' + statusDot + '</td>' +
         '<td style="text-align:center;">' + sourceIcon + '</td>' +
         '<td>' + timestampCell(createdAt) + '</td>' +
         '<td>' + timestampCell(updatedAt) + '</td>' +

console/ui/js/auth.js

@@ -93,6 +93,27 @@ function doLogout() {
   showLoginOverlay();
 }
 
+async function openAnalytics() {
+  var token = localStorage.getItem('auth_token');
+  var env = localStorage.getItem('auth_env') || 'test';
+  if (!token) { alert('Требуется авторизация'); return; }
+  try {
+    var r = await fetch(API_BASE + '/stats/dashboard-url', {
+      headers: { 'X-Auth-Token': token, 'X-Auth-Env': env }
+    });
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    var d = await r.json();
+    if (d.url) {
+      window.open(d.url, '_blank', 'noopener');
+    } else {
+      // Grafana не настроена или org ещё провизируется — ссылка на оператора
+      window.open('/grafana/', '_blank', 'noopener');
+    }
+  } catch (e) {
+    alert('Аналитика временно недоступна: ' + e.message);
+  }
+}
+
 function checkAuth() {
   var storedToken = localStorage.getItem('auth_token');
   if (!storedToken) {

console/ui/js/functions.js

@@ -151,6 +151,10 @@ function parseTimeout(v) {
 
 async function openEdit(name) {
   try {
+    var errEl = document.getElementById('e-error-msg');
+    if (errEl) errEl.style.display = 'none';
+    var cloneArea = document.getElementById('e-clone-area');
+    if (cloneArea) cloneArea.style.display = 'none';
     const fn = await getJSON(API_BASE + '/functions/' + encodeURIComponent(name));
     S.currentEdit = fn;
     document.getElementById('e-title').textContent = 'Редактирование: ' + name;
@@ -191,6 +195,11 @@ async function openEdit(name) {
       var isTf = /^tf-/.test(name) || /go[-_]env/.test(fn.environment || '');
       warnEl.style.display = isTf ? 'block' : 'none';
     }
+
+    // Env vars — отрисовать блок; TF-функции — только чтение
+    var isTfFn = /^tf-/.test(name) || /go[-_]env/.test(fn.environment || '');
+    renderEnvVars('e', fn.env_vars || [], isTfFn);
+
     document.getElementById('edit-modal').classList.add('open');
   } catch (e) {
     showStatus('Ошибка загрузки функции: ' + e.message, 'err');
@@ -238,11 +247,36 @@ async function submitEdit() {
     }
 
     await syncScheduleForFunction(name, 'e');
+    
+    // Сохраняем env vars (только если не TF-функция)
+    var isTfFn = /^tf-/.test(name);
+    if (!isTfFn) {
+      var envVars = collectEnvVars('e');
+      // Проверка формата ключей
+      var invalidKeys = envVars.map(function(ev) { return ev.name; }).filter(function(k) { return !ENV_KEY_RE.test(k); });
+      if (invalidKeys.length > 0) {
+        throw new Error('Недопустимые имена переменных: ' + invalidKeys.join(', ') + ' (только латиница, цифры, _, не с цифры)');
+      }
+      // Проверка на дубли ключей
+      var keys = envVars.map(function(ev) { return ev.name; });
+      var dupes = keys.filter(function(k, i) { return keys.indexOf(k) !== i; });
+      if (dupes.length > 0) {
+        throw new Error('Дублирующиеся ключи: ' + [...new Set(dupes)].join(', '));
+      }
+      await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name) + '/envvars', 'PUT', {
+        env_vars: envVars
+      });
+    }
+
+    var errEl = document.getElementById('e-error-msg');
+    if (errEl) errEl.style.display = 'none';
     closeEdit();
     progress.stop('Код обновлён: ' + name, 'ok');
     await reloadAll();
   } catch (e) {
-    progress.stop('Ошибка обновления: ' + e.message, 'err');
+    var errEl = document.getElementById('e-error-msg');
+    if (errEl) { errEl.textContent = e.message; errEl.style.display = 'block'; }
+    progress.stop('', '');
   } finally {
     btn.disabled = false;
   }
@@ -260,3 +294,180 @@ async function removeFn(name) {
     progress.stop('Ошибка удаления: ' + e.message, 'err');
   }
 }
+
+// --- Env Vars UI ---
+
+// renderEnvVars отрисовывает список переменных окружения в блоке prefix-envvars-list
+// vars: [{name: "KEY", value: "VAL"}, ...]
+// readOnly: true для TF-функций
+function renderEnvVars(prefix, vars, readOnly) {
+  var list = document.getElementById(prefix + '-envvars-list');
+  var addBtn = document.getElementById(prefix + '-add-envvar-btn');
+  var tfWarn = document.getElementById(prefix + '-tf-env-warn');
+  if (!list) return;
+  list.innerHTML = '';
+  if (readOnly) {
+    if (tfWarn) tfWarn.style.display = '';
+    if (addBtn) addBtn.style.display = 'none';
+  } else {
+    if (tfWarn) tfWarn.style.display = 'none';
+    if (addBtn) addBtn.style.display = '';
+  }
+  (vars || []).forEach(function(ev, idx) {
+    list.appendChild(makeEnvVarRow(prefix, ev.name || '', ev.value || '', readOnly, idx));
+  });
+}
+
+// makeEnvVarRow создаёт одну строку key=value с кнопкой удаления
+function makeEnvVarRow(prefix, key, val, readOnly, idx) {
+  var row = document.createElement('div');
+  row.style.cssText = 'display:flex; gap:6px; align-items:center;';
+  row.dataset.envIdx = idx;
+
+  var kInput = document.createElement('input');
+  kInput.placeholder = 'KEY (A-Z, a-z, 0-9, _)';
+  kInput.value = key;
+  kInput.disabled = readOnly;
+  kInput.style.cssText = 'flex:1; font-size:12px; font-family:monospace;';
+  kInput.dataset.envKey = '1';
+  // Подсветка дублей при изменении ключа
+  kInput.addEventListener('input', function() { highlightDupeKeys(prefix); });
+
+  var vInput = document.createElement('input');
+  vInput.placeholder = 'value';
+  vInput.value = val;
+  vInput.disabled = readOnly;
+  vInput.style.cssText = 'flex:2; font-size:12px; font-family:monospace;';
+  vInput.dataset.envVal = '1';
+
+  row.appendChild(kInput);
+
+  var eq = document.createElement('span');
+  eq.textContent = '=';
+  eq.style.cssText = 'color:var(--text-secondary); font-family:monospace;';
+  row.appendChild(eq);
+  row.appendChild(vInput);
+
+  if (!readOnly) {
+    var delBtn = document.createElement('button');
+    delBtn.textContent = '×';
+    delBtn.className = 'btn ghost';
+    delBtn.style.cssText = 'padding:2px 8px; font-size:14px; line-height:1;';
+    delBtn.title = 'Удалить переменную';
+    delBtn.onclick = function() { row.remove(); };
+    row.appendChild(delBtn);
+  }
+
+  return row;
+}
+
+var ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+// highlightDupeKeys подсвечивает красным все поля KEY с одинаковыми именами или невалидным именем
+function highlightDupeKeys(prefix) {
+  var list = document.getElementById(prefix + '-envvars-list');
+  if (!list) return;
+  var inputs = list.querySelectorAll('[data-env-key]');
+  var keys = Array.from(inputs).map(function(i) { return i.value.trim(); });
+  inputs.forEach(function(inp) {
+    var k = inp.value.trim();
+    var isDupe = k !== '' && keys.filter(function(x) { return x === k; }).length > 1;
+    var isInvalid = k !== '' && !ENV_KEY_RE.test(k);
+    inp.style.outline = (isDupe || isInvalid) ? '2px solid #f44' : '';
+    inp.title = isDupe ? 'Дублирующийся ключ!' : isInvalid ? 'Только латиница, цифры и _. Не начинается с цифры.' : '';
+  });
+}
+
+// addEnvVarRow добавляет пустую строку в список env vars
+function addEnvVarRow(prefix) {
+  var list = document.getElementById(prefix + '-envvars-list');
+  if (!list) return;
+  var idx = list.children.length;
+  list.appendChild(makeEnvVarRow(prefix, '', '', false, idx));
+}
+
+// collectEnvVars читает текущие значения из DOM и возвращает [{name, value}, ...]
+function collectEnvVars(prefix) {
+  var list = document.getElementById(prefix + '-envvars-list');
+  if (!list) return [];
+  var result = [];
+  var rows = list.querySelectorAll('div[data-env-idx]');
+  rows.forEach(function(row) {
+    var k = row.querySelector('[data-env-key]');
+    var v = row.querySelector('[data-env-val]');
+    var key = k ? k.value.trim() : '';
+    var val = v ? v.value : '';
+    if (key) result.push({name: key, value: val});
+  });
+  return result;
+}
+
+// toggleCloneArea показывает/скрывает форму клонирования
+function toggleCloneArea(show) {
+  var area = document.getElementById('e-clone-area');
+  var errEl = document.getElementById('e-clone-error');
+  if (!area) return;
+  area.style.display = show ? 'block' : 'none';
+  if (show) {
+    var nameInput = document.getElementById('e-clone-name');
+    if (nameInput) {
+      // Предзаполняем именем оригинала + '-copy'
+      var srcName = (S.currentEdit && S.currentEdit.name) || '';
+      nameInput.value = srcName ? srcName + '-copy' : '';
+      nameInput.focus();
+      nameInput.select();
+    }
+    if (errEl) errEl.style.display = 'none';
+  }
+}
+
+// submitClone отправляет запрос на клонирование функции
+async function submitClone() {
+  var nameInput = document.getElementById('e-clone-name');
+  var errEl = document.getElementById('e-clone-error');
+  var btn = document.querySelector('#e-clone-area .btn:not(.ghost)');
+
+  var newName = nameInput ? nameInput.value.trim() : '';
+  if (!newName) {
+    if (errEl) { errEl.textContent = 'Введите имя новой функции'; errEl.style.display = 'block'; }
+    return;
+  }
+  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(newName) || newName.length > 57) {
+    if (errEl) { errEl.textContent = 'Имя: строчные буквы, цифры, дефис; не начинается/заканчивается дефисом; до 57 символов'; errEl.style.display = 'block'; }
+    return;
+  }
+
+  var srcName = S.currentEdit && S.currentEdit.name;
+  if (!srcName) {
+    if (errEl) { errEl.textContent = 'Нет функции для клонирования'; errEl.style.display = 'block'; }
+    return;
+  }
+
+  if (btn) { btn.disabled = true; btn.textContent = '...'; }
+  if (errEl) errEl.style.display = 'none';
+
+  try {
+    var data = await requestJSON(API_BASE + '/functions/' + encodeURIComponent(srcName) + '/clone', 'POST', {new_name: newName});
+    // Успех — закрываем модалку, ждём появления в списке
+    closeEdit();
+    showStatus('Клонирование завершено, обновляем список...', '');
+    var attempts = 0;
+    async function pollUntilVisible() {
+      attempts++;
+      await reloadAll();
+      var found = (S.fns || []).some(function(f) {
+        return f && f.metadata && f.metadata.name === newName;
+      });
+      if (found || attempts >= 5) {
+        showStatus('Функция «' + newName + '» создана как копия «' + srcName + '»', 'ok');
+      } else {
+        setTimeout(pollUntilVisible, 1000);
+      }
+    }
+    setTimeout(pollUntilVisible, 700);
+  } catch(e) {
+    if (errEl) { errEl.textContent = e.message; errEl.style.display = 'block'; }
+  } finally {
+    if (btn) { btn.disabled = false; btn.textContent = 'Клонировать'; }
+  }
+}

console/ui/js/mq.js

@@ -0,0 +1,103 @@
+// mq.js — MQ-триггеры (SQS → Fission function)
+// Архитектура: Console создаёт K8s Deployment + Secret (sqs-consumer) в namespace пользователя.
+// sqs-consumer поллит SQS очередь → HTTP POST в Fission-функцию → DeleteMessage.
+// Backend: POST /console/api/mqtriggers, DELETE /console/api/mqtriggers/{name}
+// v1.3.88
+
+// ── Загрузка и отрисовка ────────────────────────────────────────────
+
+async function loadMQTriggers() {
+  try {
+    const data = await apiFetch('/console/api/mqtriggers');
+    renderMQTable(data.items || []);
+    const cnt = document.getElementById('mq-count');
+    if (cnt) cnt.textContent = (data.items || []).length;
+  } catch (e) {
+    renderMQTable([]);
+    const cnt = document.getElementById('mq-count');
+    if (cnt) cnt.textContent = '0';
+  }
+}
+
+function renderMQTable(items) {
+  const tbody = document.getElementById('mq-rows');
+  if (!tbody) return;
+  if (!items.length) {
+    tbody.innerHTML = '<tr><td colspan="6" style="color:var(--fg-muted,#888);text-align:center;">Нет MQ-триггеров</td></tr>';
+    return;
+  }
+  tbody.innerHTML = items.map(t => `
+    <tr>
+      <td>${escHtml(t.name)}</td>
+      <td>${escHtml(t.queue)}</td>
+      <td>${escHtml(t.functionName)}</td>
+      <td style="font-size:0.8em;color:var(--fg-muted,#aaa);">${escHtml(t.sqsEndpoint || '')}</td>
+      <td><span style="color:${t.ready ? '#4a4' : '#a44'}">${t.ready ? '▶ Running' : '◼ Pending'}</span></td>
+      <td>
+        <button class="btn ghost small" onclick="deleteMQTrigger('${escHtml(t.name)}')">Удалить</button>
+      </td>
+    </tr>
+  `).join('');
+}
+
+// ── Создание ─────────────────────────────────────────────────────────
+
+function openCreateMQ() {
+  document.getElementById('mq-name').value = '';
+  document.getElementById('mq-fn').value = '';
+  document.getElementById('mq-queue').value = '';
+  document.getElementById('mq-endpoint').value = 'http://shared-sqs.shared-sqs.svc.cluster.local:4100';
+  document.getElementById('mq-access-key').value = '';
+  document.getElementById('mq-secret-key').value = '';
+  document.getElementById('mq-create-error').textContent = '';
+  document.getElementById('mq-create-modal').style.display = 'flex';
+}
+
+function closeMQCreate() {
+  document.getElementById('mq-create-modal').style.display = 'none';
+}
+
+async function submitCreateMQ() {
+  const name        = document.getElementById('mq-name').value.trim();
+  const fnName      = document.getElementById('mq-fn').value.trim();
+  const queue       = document.getElementById('mq-queue').value.trim();
+  const endpoint    = document.getElementById('mq-endpoint').value.trim();
+  const accessKey   = document.getElementById('mq-access-key').value.trim();
+  const secretKey   = document.getElementById('mq-secret-key').value.trim();
+  const errEl       = document.getElementById('mq-create-error');
+
+  if (!name || !fnName || !queue || !accessKey || !secretKey) {
+    errEl.textContent = 'Заполните все поля';
+    return;
+  }
+
+  errEl.textContent = '';
+  try {
+    await apiFetch('/console/api/mqtriggers', {
+      method: 'POST',
+      body: JSON.stringify({ name, functionName: fnName, queue, sqsEndpoint: endpoint, accessKey, secretKey })
+    });
+    closeMQCreate();
+    await loadMQTriggers();
+  } catch (e) {
+    errEl.textContent = e.message || 'Ошибка создания';
+  }
+}
+
+// ── Удаление ─────────────────────────────────────────────────────────
+
+async function deleteMQTrigger(name) {
+  if (!confirm(`Удалить MQ-триггер "${name}"?`)) return;
+  try {
+    await apiFetch(`/console/api/mqtriggers/${encodeURIComponent(name)}`, { method: 'DELETE' });
+    await loadMQTriggers();
+  } catch (e) {
+    alert('Ошибка удаления: ' + (e.message || e));
+  }
+}
+
+// ── Утилита ──────────────────────────────────────────────────────────
+
+function escHtml(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}

deploy/grafana/configmap-dashboard-fission.yaml

@@ -0,0 +1,102 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: grafana-dashboard-fission
+  namespace: grafana
+data:
+  fission-overview.json: |
+    {
+      "title": "Fission — Operator Overview",
+      "uid": "fission-overview",
+      "tags": ["fission"],
+      "timezone": "browser",
+      "refresh": "30s",
+      "time": { "from": "now-24h", "to": "now" },
+      "templating": {
+        "list": [
+          {
+            "name": "namespace",
+            "type": "query",
+            "datasource": { "type": "postgres", "uid": "fission-pg" },
+            "query": "SELECT DISTINCT namespace FROM invocations ORDER BY 1",
+            "includeAll": true,
+            "multi": true,
+            "label": "Namespace",
+            "current": { "text": "All", "value": "$__all" }
+          }
+        ]
+      },
+      "panels": [
+        {
+          "id": 1,
+          "title": "Вызовы в час",
+          "type": "timeseries",
+          "gridPos": { "x": 0, "y": 0, "w": 16, "h": 8 },
+          "datasource": { "type": "postgres", "uid": "fission-pg" },
+          "targets": [
+            {
+              "rawSql": "SELECT date_trunc('hour', started_at) AS time, count(*) AS value, namespace FROM invocations WHERE started_at BETWEEN $__timeFrom() AND $__timeTo() AND ('$namespace' = '$__all' OR namespace = ANY(string_to_array('$namespace', ','))) GROUP BY 1, namespace ORDER BY 1",
+              "format": "time_series",
+              "refId": "A"
+            }
+          ]
+        },
+        {
+          "id": 2,
+          "title": "Успех vs Ошибки",
+          "type": "piechart",
+          "gridPos": { "x": 16, "y": 0, "w": 8, "h": 8 },
+          "datasource": { "type": "postgres", "uid": "fission-pg" },
+          "targets": [
+            {
+              "rawSql": "SELECT CASE WHEN status_code >= 200 AND status_code < 300 THEN 'success' ELSE 'error' END AS metric, count(*) AS value FROM invocations WHERE started_at BETWEEN $__timeFrom() AND $__timeTo() AND ('$namespace' = '$__all' OR namespace = ANY(string_to_array('$namespace', ','))) GROUP BY 1",
+              "format": "table",
+              "refId": "A"
+            }
+          ]
+        },
+        {
+          "id": 3,
+          "title": "Топ функций по вызовам",
+          "type": "bargauge",
+          "gridPos": { "x": 0, "y": 8, "w": 12, "h": 8 },
+          "datasource": { "type": "postgres", "uid": "fission-pg" },
+          "targets": [
+            {
+              "rawSql": "SELECT function_name AS metric, count(*) AS value FROM invocations WHERE started_at BETWEEN $__timeFrom() AND $__timeTo() AND ('$namespace' = '$__all' OR namespace = ANY(string_to_array('$namespace', ','))) GROUP BY 1 ORDER BY 2 DESC LIMIT 10",
+              "format": "table",
+              "refId": "A"
+            }
+          ]
+        },
+        {
+          "id": 4,
+          "title": "Средняя латентность (ms)",
+          "type": "timeseries",
+          "gridPos": { "x": 12, "y": 8, "w": 12, "h": 8 },
+          "datasource": { "type": "postgres", "uid": "fission-pg" },
+          "targets": [
+            {
+              "rawSql": "SELECT date_trunc('hour', started_at) AS time, round(avg(duration_ms)) AS avg_ms, round(percentile_cont(0.95) WITHIN GROUP (ORDER BY duration_ms)) AS p95_ms FROM invocations WHERE started_at BETWEEN $__timeFrom() AND $__timeTo() AND ('$namespace' = '$__all' OR namespace = ANY(string_to_array('$namespace', ','))) GROUP BY 1 ORDER BY 1",
+              "format": "time_series",
+              "refId": "A"
+            }
+          ]
+        },
+        {
+          "id": 5,
+          "title": "Последние вызовы",
+          "type": "table",
+          "gridPos": { "x": 0, "y": 16, "w": 24, "h": 8 },
+          "datasource": { "type": "postgres", "uid": "fission-pg" },
+          "targets": [
+            {
+              "rawSql": "SELECT started_at AS time, namespace, function_name, trigger_type, event_type, status_code, duration_ms FROM invocations WHERE ('$namespace' = '$__all' OR namespace = ANY(string_to_array('$namespace', ','))) ORDER BY started_at DESC LIMIT 50",
+              "format": "table",
+              "refId": "A"
+            }
+          ]
+        }
+      ],
+      "schemaVersion": 38
+    }

deploy/grafana/configmap-dashboard-providers.yaml

@@ -0,0 +1,15 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: grafana-dashboard-providers
+  namespace: grafana
+data:
+  providers.yaml: |
+    apiVersion: 1
+    providers:
+      - name: fission
+        type: file
+        disableDeletion: false
+        editable: true
+        options:
+          path: /var/lib/grafana/dashboards

deploy/grafana/configmap-datasources.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: grafana-datasources
+  namespace: grafana
+data:
+  postgres.yaml: |
+    apiVersion: 1
+    datasources:
+      - name: PostgreSQL
+        type: postgres
+        uid: fission-pg
+        url: postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432
+        database: sqsdb
+        user: super
+        secureJsonData:
+          password: "BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif"
+        jsonData:
+          sslmode: disable
+          postgresVersion: 1700
+          timescaledb: false
+        editable: false

deploy/grafana/deployment.yaml

@@ -0,0 +1,98 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: grafana
+  namespace: grafana
+  labels:
+    app: grafana
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: grafana
+  template:
+    metadata:
+      labels:
+        app: grafana
+    spec:
+      securityContext:
+        fsGroup: 472
+        runAsUser: 472
+      containers:
+        - name: grafana
+          image: grafana/grafana:11.6.1
+          imagePullPolicy: IfNotPresent
+          ports:
+            - containerPort: 3000
+          env:
+            - name: GF_SECURITY_ADMIN_USER
+              valueFrom:
+                secretKeyRef:
+                  name: grafana-admin
+                  key: admin-user
+            - name: GF_SECURITY_ADMIN_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: grafana-admin
+                  key: admin-password
+            - name: GF_SERVER_ROOT_URL
+              value: "https://fission.kube5s.ru/grafana"
+            - name: GF_SERVER_DOMAIN
+              value: "fission.kube5s.ru"
+            - name: GF_SERVER_SERVE_FROM_SUB_PATH
+              value: "true"
+            - name: GF_USERS_ALLOW_SIGN_UP
+              value: "false"
+            - name: GF_AUTH_ANONYMOUS_ENABLED
+              value: "false"
+            - name: GF_ORGS_AUTO_ASSIGN_ORG
+              value: "true"
+            - name: GF_ORGS_AUTO_ASSIGN_ORG_ID
+              value: "1"
+            - name: GF_ORGS_AUTO_ASSIGN_ORG_ROLE
+              value: "Viewer"
+            - name: GF_FEATURE_TOGGLES_ENABLE
+              value: "publicDashboards"
+            - name: GF_PATHS_PROVISIONING
+              value: "/etc/grafana/provisioning"
+          volumeMounts:
+            - name: storage
+              mountPath: /var/lib/grafana
+            - name: datasources
+              mountPath: /etc/grafana/provisioning/datasources
+            - name: dashboard-providers
+              mountPath: /etc/grafana/provisioning/dashboards
+            - name: dashboards
+              mountPath: /var/lib/grafana/dashboards
+          resources:
+            requests:
+              cpu: 50m
+              memory: 128Mi
+            limits:
+              cpu: 500m
+              memory: 256Mi
+          livenessProbe:
+            httpGet:
+              path: /grafana/api/health
+              port: 3000
+            initialDelaySeconds: 30
+            periodSeconds: 30
+          readinessProbe:
+            httpGet:
+              path: /grafana/api/health
+              port: 3000
+            initialDelaySeconds: 10
+            periodSeconds: 10
+      volumes:
+        - name: storage
+          persistentVolumeClaim:
+            claimName: grafana-storage
+        - name: datasources
+          configMap:
+            name: grafana-datasources
+        - name: dashboard-providers
+          configMap:
+            name: grafana-dashboard-providers
+        - name: dashboards
+          configMap:
+            name: grafana-dashboard-fission

deploy/grafana/ingress-subpath.yaml

@@ -0,0 +1,28 @@
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: grafana-subpath
+  namespace: grafana
+  annotations:
+    # Без rewrite — Grafana сама обрабатывает /grafana/... через serve_from_sub_path
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
+spec:
+  ingressClassName: nginx
+  rules:
+    - host: fission.kube5s.ru
+      http:
+        paths:
+          - path: /grafana
+            pathType: Prefix
+            backend:
+              service:
+                name: grafana
+                port:
+                  number: 3000
+# TLS не нужен — управляется Ingress в namespace fission (fission-tls)
+# При миграции на grafana.kube5s.ru:
+#   1. Поменять GF_SERVER_ROOT_URL → https://grafana.kube5s.ru
+#   2. Убрать GF_SERVER_SERVE_FROM_SUB_PATH (или оставить false)
+#   3. Создать Ingress в namespace grafana с host grafana.kube5s.ru + TLS
+#   4. Удалить этот файл

deploy/grafana/namespace.yaml

@@ -0,0 +1,4 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: grafana

deploy/grafana/pvc.yaml

@@ -0,0 +1,11 @@
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: grafana-storage
+  namespace: grafana
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 2Gi

deploy/grafana/secret.yaml

@@ -0,0 +1,9 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: grafana-admin
+  namespace: grafana
+type: Opaque
+stringData:
+  admin-user: admin
+  admin-password: "GrafanaAdmin2026!"

deploy/grafana/service-ingress.yaml

@@ -0,0 +1,37 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: grafana
+  namespace: grafana
+spec:
+  selector:
+    app: grafana
+  ports:
+    - port: 3000
+      targetPort: 3000
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: grafana
+  namespace: grafana
+  annotations:
+    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
+    cert-manager.io/cluster-issuer: "letsencrypt-prod"
+spec:
+  ingressClassName: nginx
+  tls:
+    - hosts:
+        - grafana.kube5s.ru
+      secretName: grafana-tls
+  rules:
+    - host: grafana.kube5s.ru
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: grafana
+                port:
+                  number: 3000

doc/descriptions/function-envvars-flow.md

@@ -0,0 +1,128 @@
+# Function Env Vars — ПОЛНАЯ ДОКУМЕНТАЦИЯ (v1.3.77+)
+
+## ПРОБЛЕМА (обнаружена 2026-05-09)
+
+Env vars хранились только в аннотации `fission-console/env-vars` на Function CRD.
+Это работало для UI (хранение/отображение), но переменные **не попадали в pod функции**.
+
+### Почему не попадали
+
+Fission `poolmgr` создаёт warm pool подов **заранее**, до того как знает какая функция
+будет запущена. Pod уже работает в момент первого вызова функции.
+`spec.podspec.containers[].env` из Function CRD при poolmgr **игнорируется** — pod уже запущен.
+
+При специализации (загрузке кода функции) fetcher передаёт в pod только:
+- путь к файлу с кодом
+- имя entrypoint функции
+- секреты и configmaps (как файлы в `/userfunc/...`)
+
+Переменные окружения через `poolmgr` можно установить только на уровне Environment deployment —
+одинаковые для ВСЕХ функций этого окружения. Индивидуально для функции — невозможно.
+
+### Отвергнутые варианты
+
+| Вариант | Почему нет |
+|---------|-----------|
+| `spec.podspec.containers[].env` + poolmgr | Pod уже запущен до специализации |
+| `spec.configmaps` → файлы `/userfunc/configs/` | Нужно читать файл в коде — не универсально |
+| Патч python-env server | Только Python, другие языки сломаны |
+| PostgreSQL/отдельное хранилище | Оверкилл, не официальный путь |
+
+---
+
+## РЕШЕНИЕ (v1.3.77+)
+
+**Автоматическое переключение ExecutorType в зависимости от наличия env vars.**
+
+- Функция **без env vars** → `ExecutorType: poolmgr` → warm pool, быстрый cold start (~0.5 сек)
+- Функция **с env vars** → `ExecutorType: newdeploy` → dedicated Deployment, env vars в OS (~2-5 сек)
+
+Пользователь ничего не настраивает — переключение происходит автоматически.
+
+### Почему newdeploy работает
+
+При `newdeploy` Fission создаёт отдельный Kubernetes `Deployment` для функции.
+В этот Deployment попадает `spec.podspec` из Function CRD **включая** `containers[0].env`.
+Kubernetes ставит переменные на уровне ОС процесса контейнера при старте пода.
+
+### Почему это универсально для всех языков
+
+Переменные окружения ОС — стандарт POSIX. Любой язык читает без изменений в env-сервере:
+
+```python
+os.getenv("MY_VAR")          # Python
+os.Getenv("MY_VAR")          # Go
+ENV["MY_VAR"]                # Ruby
+getenv("MY_VAR")             # PHP
+process.env.MY_VAR           # Node.js
+```
+
+### Нет дублирования подов
+
+Warm pool принадлежит **Environment**, не функции. Переключение конкретной функции на `newdeploy`
+не трогает pool — другие функции без env vars продолжают использовать его.
+
+---
+
+## РЕАЛИЗАЦИЯ
+
+### Backend: `handlePutFunctionEnvVars` (function_crud.go)
+
+При `PUT /functions/:name/envvars`:
+
+1. Сохраняет env vars в аннотацию `fission-console/env-vars` (для UI)
+2. Если env vars **непустые**:
+   - Выставляет `spec.podspec.containers[0].env` (стандартный Kubernetes EnvVar)
+   - Переключает `spec.InvokeStrategy.ExecutionStrategy.ExecutorType` = `"newdeploy"`
+   - MinScale=0, MaxScale=1
+3. Если env vars **пустые** (очищены):
+   - Удаляет `spec.podspec`
+   - Возвращает `ExecutorType` = `"poolmgr"`
+
+### Двойное хранение
+
+| Где | Зачем |
+|-----|-------|
+| Аннотация `fission-console/env-vars` | UI: отображение, редактирование |
+| `spec.podspec.containers[0].env` | Fission/Kubernetes: реальное применение в pod |
+
+### Структура Function CRD с env vars
+
+```yaml
+spec:
+  InvokeStrategy:
+    ExecutionStrategy:
+      ExecutorType: newdeploy
+      MinScale: 0
+      MaxScale: 1
+    StrategyType: execution
+  podspec:
+    containers:
+      - name: <env-name>
+        env:
+          - name: p1
+            value: "envv1"
+metadata:
+  annotations:
+    fission-console/env-vars: '[{"name":"p1","value":"envv1"}]'
+```
+
+### Структура Function CRD без env vars
+
+```yaml
+spec:
+  InvokeStrategy:
+    ExecutionStrategy:
+      ExecutorType: poolmgr
+    StrategyType: execution
+  # нет podspec
+```
+
+---
+
+## ОГРАНИЧЕНИЯ
+
+- `newdeploy` медленнее cold start (~2-5 сек vs ~0.5 сек) — выбор пользователя, добавившего env vars
+- MinScale=0: при отсутствии трафика pod удаляется → cold start при первом вызове
+- Имена переменных: только `[A-Za-z_][A-Za-z0-9_]*` — стандарт POSIX, проверяется на UI
+- TF-функции (`tf-*`) — env vars read-only, изменение запрещено через UI

doc/progress.md

@@ -17,12 +17,180 @@
 - UI: формы создания по аналогии с cron, счётчики на главной
 
 ### Прочий полезный функционал
+- ~~Клонировать функцию (копия с новым именем)~~ ✅ v1.3.80
+- ~~Переменные окружения (env vars) через UI~~ ✅ v1.3.78
 - Метрики на главной странице (данные уже есть в metrics-collector)
 - Автообновление логов (polling каждые 3-5 сек)
 - Копировать маршрут одной кнопкой (📋 рядом с маршрутом)
-- Статус функции (Ready/NotReady/Error) в таблице
-- Клонировать функцию (копия с новым именем)
-- Переменные окружения (env vars) через UI
+
+---
+
+## 2026-05-09 — 2026-05-10
+
+### Ветка: `feat/function-status-clone-envvars` / `feat/clone-function`
+
+---
+
+#### v1.3.78 — Переменные окружения: патч Deployment напрямую
+
+**Проблема:** Fission newdeploy executor игнорирует `fn.Spec.PodSpec` при построении
+Deployment — применяет только `env.Spec.Runtime.Container`. Сохранение env vars в
+Function CRD через UI не приводило к попаданию переменных в pod.
+
+**Решение:** После обновления Function CRD — дополнительно патчить Deployment
+напрямую через Kubernetes API (`StrategicMergePatch`).
+
+- Файл: `console/internal/api/function_crud.go`
+- Новая функция `patchDeploymentEnvVars(ctx, ns, fnName, envContainerName, envVars)`
+- Поиск Deployment по labels: `functionName=<name>,functionNamespace=<ns>,executorType=newdeploy`
+- Patch: `StrategicMergePatch` с `containers[{name: envContainerName, env: [...]}]`
+- Импорт добавлен: `k8stypes "k8s.io/apimachinery/pkg/types"`
+- Образ: `naeel/fission-console:v1.3.78`
+
+---
+
+#### v1.3.79 — LLM: убрано ограничение тем чата + сброс кэша роутера
+
+**Проблема 1:** LLM ассистент отказывался отвечать на вопросы не по теме Fission Console.
+
+**Решение:** Удалён блок `## Чем НЕ занимаешься` из `buildChatSystemPrompt()` в
+`console/internal/api/ai_prompts.go`.
+
+**Проблема 2:** Env vars всё ещё не работали после v1.3.78 — роутер закешировал
+старый poolmgr адрес (funcSvc cache).
+
+**Решение:** `kubectl rollout restart deployment/router -n fission` — сбросил кэш.
+После перезапуска env vars начали попадать в поды.
+
+- Образ: `naeel/fission-console:v1.3.79`
+
+---
+
+#### v1.3.80 — Клонирование функции (полная реализация)
+
+**Фича:** `POST /functions/:name/clone` — создаёт полную копию функции с новым именем.
+
+**Backend** (`console/internal/api/function_clone.go`, новый файл):
+1. Валидирует `new_name` (regex `^[a-z0-9]([a-z0-9-]*[a-z0-9])?$`, ≤57 символов)
+2. Скачивает архив из storagesvc (type:url) или base64 (type:literal)
+3. Заливает как новый архив в storagesvc (новый S3-объект — удаление оригинала не ломает клон)
+4. Создаёт новый Package с именем `<new_name>-<timestamp>`
+5. Копирует аннотации: `language`, `source-type`, `env-vars`, `archive-filename`, добавляет `cloned-from`
+6. Копирует entrypoint, timeout, InvokeStrategy, podspec
+7. Создаёт Function CRD
+8. Копирует HTTP методы из оригинального триггера, создаёт HTTPTrigger
+9. При ошибке Function/Trigger — откатывает созданные Package/Function
+
+**Route** (`console/internal/api/handlers.go`):
+```
+POST /functions/:name/clone
+```
+
+**Frontend** (`console/ui/index.html`, `console/ui/js/functions.js`):
+- Кнопка **📋 Клон** в нижней панели edit modal
+- Inline форма: поле имени, кнопки «Клонировать» / «✕»
+- Предзаполнение именем `<original>-copy`
+- Валидация на клиенте (тот же regex)
+- При успехе: закрытие модалки + polling до появления в таблице
+
+**Тест результат:**
+```
+POST /console/api/functions/clone-src/clone {"new_name":"clone-src-copy"}
+→ 201 {"cloned_from":"clone-src","name":"clone-src-copy","package":"clone-src-copy-20260509162619","route":"/47b6ef5e8225/clone-src-copy"}
+kubectl get function clone-src-copy       ✅
+kubectl get package clone-src-copy-...    ✅ type:url storagesvc
+kubectl get httptrigger clone-src-copy-route  ✅ methods=["GET"]
+annotation: fission-console/cloned-from=clone-src  ✅
+```
+
+- Образ: `naeel/fission-console:v1.3.80`
+
+---
+
+#### v1.3.81 — Fix: clone не обновлял таблицу (`loadFunctions` → `reloadAll`)
+
+**Проблема:** После клонирования таблица не обновлялась — функция `loadFunctions()`
+не существует, правильное название `reloadAll()`.
+
+**Fix:** `console/ui/js/functions.js` — замена вызова.
+
+- Образ: `naeel/fission-console:v1.3.81`
+
+---
+
+#### v1.3.82 — Fix: `apiFetch is not defined` → `requestJSON`
+
+**Проблема:** `apiFetch` не существует в codebase. Правильный хелпер — `requestJSON(url, method, body)` из `api.js`.
+
+**Fix:** `console/ui/js/functions.js` — переписан `submitClone()` на `requestJSON`.
+
+- Образ: `naeel/fission-console:v1.3.82`
+
+---
+
+#### v1.3.83 — Fix: clone — задержка 800мс перед reloadAll (race condition)
+
+**Проблема:** После клонирования таблица обновлялась раньше, чем k8s возвращал
+новый объект в List-ответе.
+
+**Fix:** `setTimeout(reloadAll, 800)` → заменено на polling с ожиданием появления
+функции в `S.fns` (до 5 попыток × 1 сек).
+
+- Образ: `naeel/fission-console:v1.3.83`
+
+---
+
+#### v1.3.84 — Help + LLM промпты: разделы env vars и clone
+
+**Help modal** (`console/ui/index.html`):
+- Новая секция **«Переменные окружения функции»**: как добавлять через UI, как читать в коде (`os.environ` / `process.env` / `os.Getenv`)
+- Новая секция **«Клонирование функции»**: кнопка 📋 Клон, что копируется, правила имени
+
+**LLM системный промпт** (`console/internal/api/ai_prompts.go`):
+- В раздел «Редактирование функции» добавлены пункты «Переменные окружения» и «📋 Клон»
+
+- Образ: `naeel/fission-console:v1.3.84`
+
+---
+
+#### v1.3.85 — Fix: polling до появления клона в таблице
+
+**Проблема:** После клонирования — резкий переход в таблицу, клон ещё не виден
+(k8s list не успел вернуть новый объект).
+
+**Fix:** `console/ui/js/functions.js` — polling loop:
+1. Закрыть модалку
+2. Показать статус «Клонирование завершено, обновляем список...»
+3. Через 700мс — `reloadAll()`
+4. Проверить `S.fns` на наличие нового имени
+5. Если не найден — повторить через 1 сек (до 5 попыток)
+6. Показать финальное сообщение
+
+- Образ: `naeel/fission-console:v1.3.85`
+
+---
+
+#### Unit-тесты (`console/internal/api/function_clone_test.go`)
+
+21 тест, все PASS. Файл создан с нуля.
+
+| Группа | Тесты |
+|---|---|
+| Валидация имени | пустое → 400; uppercase → 400; начинается с `-` → 400; заканчивается `-` → 400; 58 символов → 400; 57 символов → OK (404); имя с дефисами → OK |
+| Источник не найден | 404 с именем функции в теле |
+| Успешный клон (type:literal) | Package создан; Function создана; аннотации `cloned-from`, `language`, `source-type` скопированы; entrypoint и timeout скопированы; HTTPTrigger с методами и маршрутом |
+| Маршрут | явный `/custom/path`; автодобавление `/` при отсутствии |
+| Конфликт имени | дублирующее → 409 |
+| Откат | ошибка создания Function → Package удалён |
+| downloadPackageBytes | type:literal; type:url; пустой Package → ошибка |
+| downloadFromStoragesvc | HTTP 404 → ошибка с кодом |
+| getTriggerMethods | триггер найден; триггер не найден |
+| Невалидный JSON | → 400 |
+| Ссылка Package→Function | `spec.package.packageref.name` совпадает с реальным Package |
+
+```
+ok  fission-console/internal/api  0.040s
+```
 
 ---
 

examples/weather-demo/consumer/main.py

@@ -0,0 +1,51 @@
+import os
+import json
+import psycopg2
+
+
+def main(event, context):
+    pg_dsn = os.environ.get(
+        "PG_DSN",
+        "postgresql://super:BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif"
+        "@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432"
+        "/sqsdb?sslmode=disable",
+    )
+
+    # Извлекаем тело сообщения из SQS (POST от sqs-consumer)
+    # event — Flask Request object: используем .data (bytes) или .get_json()
+    try:
+        data = event.get_json(force=True, silent=False)
+    except Exception:
+        raw = getattr(event, "data", None) or getattr(event, "body", b"")
+        if isinstance(raw, (bytes, bytearray)):
+            raw = raw.decode("utf-8")
+        data = json.loads(raw) if raw else {}
+
+    conn = psycopg2.connect(pg_dsn)
+    try:
+        cur = conn.cursor()
+        cur.execute(
+            """
+            INSERT INTO weather_metrics
+                (city, country, temperature, feels_like, humidity,
+                 pressure, wind_speed, description, recorded_at)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, to_timestamp(%s))
+            """,
+            (
+                data["city"],
+                data["country"],
+                data["temperature"],
+                data["feels_like"],
+                data["humidity"],
+                data["pressure"],
+                data["wind_speed"],
+                data["description"],
+                data["owm_timestamp"],
+            ),
+        )
+        conn.commit()
+        cur.close()
+    finally:
+        conn.close()
+
+    return {"status": "ok", "city": data["city"], "temp": data["temperature"]}

examples/weather-demo/consumer/requirements.txt

@@ -0,0 +1 @@
+psycopg2-binary==2.9.9

examples/weather-demo/fetcher/main.py

@@ -0,0 +1,92 @@
+import os
+import json
+import time
+import requests
+import boto3
+from botocore.config import Config
+
+# Open-Meteo: бесплатный API без ключа, реальные данные.
+# https://open-meteo.com/en/docs
+CITIES = [
+    {"name": "Moscow",    "country": "RU", "lat": 55.7558,  "lon":  37.6173},
+    {"name": "London",    "country": "GB", "lat": 51.5074,  "lon":  -0.1278},
+    {"name": "Paphos",    "country": "CY", "lat": 34.7753,  "lon":  32.4242},
+    {"name": "Ulyanovsk", "country": "RU", "lat": 54.3282,  "lon":  48.3866},
+    {"name": "Santiago",  "country": "CL", "lat": -33.4489, "lon": -70.6693},
+]
+
+# WMO weather code → описание
+WMO_DESCRIPTIONS = {
+    0: "clear sky", 1: "mainly clear", 2: "partly cloudy", 3: "overcast",
+    45: "fog", 48: "icy fog", 51: "light drizzle", 53: "drizzle",
+    55: "heavy drizzle", 61: "light rain", 63: "rain", 65: "heavy rain",
+    71: "light snow", 73: "snow", 75: "heavy snow", 80: "rain showers",
+    81: "showers", 82: "violent showers", 95: "thunderstorm",
+}
+
+
+def fetch_city(city):
+    params = {
+        "latitude": city["lat"],
+        "longitude": city["lon"],
+        "current": "temperature_2m,apparent_temperature,relative_humidity_2m,surface_pressure,wind_speed_10m,weather_code",
+        "wind_speed_unit": "ms",
+        "timezone": "UTC",
+    }
+    resp = requests.get(
+        "https://api.open-meteo.com/v1/forecast",
+        params=params,
+        timeout=10,
+    )
+    resp.raise_for_status()
+    cur = resp.json()["current"]
+    code = cur.get("weather_code", 0)
+    return {
+        "city": city["name"],
+        "country": city["country"],
+        "temperature": round(cur["temperature_2m"], 1),
+        "feels_like": round(cur["apparent_temperature"], 1),
+        "humidity": int(cur["relative_humidity_2m"]),
+        "pressure": int(cur["surface_pressure"]),
+        "wind_speed": round(cur["wind_speed_10m"], 1),
+        "description": WMO_DESCRIPTIONS.get(code, f"wmo:{code}"),
+        "owm_timestamp": int(time.time()),
+    }
+
+
+def main(event, context):
+    sqs_endpoint = os.environ.get(
+        "SQS_ENDPOINT", "http://shared-sqs.shared-sqs.svc.cluster.local:4100"
+    )
+    access_key = os.environ.get("SQS_ACCESS_KEY", "SSAK-a9964f2723bc6d347f48d153")
+    secret_key = os.environ.get(
+        "SQS_SECRET_KEY",
+        "2069e1ce05aaf94efe07aee18697352879e7626df239a9c71af0e9650b43bdd6",
+    )
+    queue_name = os.environ.get("SQS_QUEUE_NAME", "weather-data")
+
+    cfg = Config(signature_version="s3v4", s3={"addressing_style": "path"})
+    sqs = boto3.client(
+        "sqs",
+        endpoint_url=sqs_endpoint,
+        aws_access_key_id=access_key,
+        aws_secret_access_key=secret_key,
+        region_name="us-east-1",
+        config=cfg,
+    )
+
+    try:
+        queue_url = sqs.get_queue_url(QueueName=queue_name)["QueueUrl"]
+    except Exception:
+        queue_url = sqs.create_queue(QueueName=queue_name)["QueueUrl"]
+
+    results = []
+    for city in CITIES:
+        try:
+            msg = fetch_city(city)
+            sqs.send_message(QueueUrl=queue_url, MessageBody=json.dumps(msg))
+            results.append({"city": msg["city"], "temp": msg["temperature"]})
+        except Exception as e:
+            results.append({"city": city["name"], "error": str(e)})
+
+    return {"status": "ok", "sent": len(results), "results": results}

examples/weather-demo/fetcher/requirements.txt

@@ -0,0 +1,2 @@
+requests==2.31.0
+boto3==1.34.0

examples/weather-demo/main.tf

@@ -0,0 +1,143 @@
+terraform {
+  required_providers {
+    fission = {
+      source  = "nail/fission"
+      version = "~> 0.2.0"
+    }
+  }
+}
+
+provider "fission" {
+  kubeconfig_path = var.kubeconfig_path
+  namespace       = var.namespace
+}
+
+# ── Переменные ───────────────────────────────────────────────────────
+
+variable "kubeconfig_path" {
+  default     = "/home/naeel/.kube/config"
+  description = "Путь к kubeconfig."
+}
+
+variable "namespace" {
+  default     = "fission-weather"
+  description = "Namespace для функций и триггеров."
+}
+
+variable "sqs_access_key" {
+  sensitive   = true
+  description = "SQS Access Key."
+}
+
+variable "sqs_secret_key" {
+  sensitive   = true
+  description = "SQS Secret Key."
+}
+
+variable "pg_dsn" {
+  sensitive   = true
+  description = "PostgreSQL DSN для записи метрик. Пример: postgresql://user:pass@host:5432/db?sslmode=disable"
+}
+
+# ── IoT-устройство — виртуальная метеостанция ────────────────────────
+
+resource "fission_iot_device" "weather_station" {
+  name      = "weather-station"
+  device_id = "weather-station-01"
+  namespace = "sless"
+  metadata = {
+    type     = "weather-station"
+    location = "multi-city"
+    cities   = "Moscow,London,Paphos,Ulyanovsk,Santiago"
+  }
+}
+
+# ── Python environment ───────────────────────────────────────────────
+
+resource "fission_environment" "python" {
+  name      = "weather-python"
+  image     = "naeel/fission-python-env:v1.1"
+  version   = 2
+  namespace = var.namespace
+}
+
+# ── Пакет: fetcher ───────────────────────────────────────────────────
+
+resource "fission_package" "fetcher" {
+  name        = "weather-fetcher-pkg"
+  environment = fission_environment.python.name
+  namespace   = var.namespace
+  source_dir  = "${path.module}/fetcher"
+  deploy_type = "literal"
+}
+
+# ── Пакет: consumer ──────────────────────────────────────────────────
+
+resource "fission_package" "consumer" {
+  name        = "weather-consumer-pkg"
+  environment = fission_environment.python.name
+  namespace   = var.namespace
+  source_dir  = "${path.module}/consumer"
+  deploy_type = "literal"
+}
+
+# ── Функция: fetcher (читает Open-Meteo, пишет в SQS) ───────────────
+# Open-Meteo: бесплатный API без ключа. https://open-meteo.com
+resource "fission_function" "fetcher" {
+  name         = "weather-fetcher"
+  environment  = fission_environment.python.name
+  namespace    = var.namespace
+  package_name = fission_package.fetcher.name
+  entrypoint   = "main"
+  # Env vars задаются через K8s Secret weather-fetcher-env (namespace: var.namespace)
+  # Ключи: SQS_ACCESS_KEY, SQS_SECRET_KEY
+}
+
+# ── CRON trigger: каждые 10 минут ────────────────────────────────────
+
+resource "fission_cron_trigger" "fetcher" {
+  name      = "weather-cron"
+  function  = fission_function.fetcher.name
+  namespace = var.namespace
+  cron      = "*/10 * * * *"
+}
+
+# ── Функция: consumer (читает из SQS, пишет в PG) ────────────────────
+
+resource "fission_function" "consumer" {
+  name         = "weather-consumer"
+  environment  = fission_environment.python.name
+  namespace    = var.namespace
+  package_name = fission_package.consumer.name
+  entrypoint   = "main"
+  # Env vars: PG_DSN задаётся через K8s Secret weather-consumer-env
+}
+
+# ── MQ trigger: SQS queue → consumer function ────────────────────────
+
+resource "fission_mq_trigger" "weather" {
+  name         = "weather-mq"
+  function     = fission_function.consumer.name
+  namespace    = var.namespace
+  queue        = "weather-data"
+  access_key   = var.sqs_access_key
+  secret_key   = var.sqs_secret_key
+  sqs_endpoint = "http://shared-sqs.shared-sqs.svc.cluster.local:4100"
+}
+
+# ── Outputs ──────────────────────────────────────────────────────────
+
+output "iot_device_phase" {
+  value       = fission_iot_device.weather_station.phase
+  description = "Статус IoT-устройства weather-station."
+}
+
+output "iot_mqtt_username" {
+  value       = fission_iot_device.weather_station.mqtt_username
+  description = "MQTT username для weather-station."
+}
+
+output "iot_topic_prefix" {
+  value       = fission_iot_device.weather_station.topic_prefix
+  description = "MQTT topic prefix для weather-station."
+}

examples/weather-demo/migration.sql

@@ -0,0 +1,18 @@
+-- Миграция: таблица метрик погоды для weather-demo
+-- Применять: psql $PG_DSN -f migration.sql
+
+CREATE TABLE IF NOT EXISTS weather_metrics (
+    id          BIGSERIAL PRIMARY KEY,
+    city        TEXT        NOT NULL,
+    country     TEXT        NOT NULL,
+    temperature NUMERIC(5,2),
+    feels_like  NUMERIC(5,2),
+    humidity    INTEGER,
+    pressure    INTEGER,
+    wind_speed  NUMERIC(6,2),
+    description TEXT,
+    recorded_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_weather_city_time
+    ON weather_metrics (city, recorded_at DESC);

examples/weather-demo/terraform.tfvars.example

@@ -0,0 +1,10 @@
+# Скопируй в terraform.tfvars и заполни значения.
+# НЕ коммитить файл с реальными секретами!
+
+kubeconfig_path = "/home/naeel/.kube/config"
+namespace       = "fission-weather"
+
+owm_api_key    = "YOUR_OPENWEATHERMAP_API_KEY"
+sqs_access_key = "SSAK-a9964f2723bc6d347f48d153"
+sqs_secret_key = "YOUR_SQS_SECRET_KEY"
+pg_dsn         = "postgresql://super:PASSWORD@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432/sqsdb?sslmode=disable"

plan.md

@@ -0,0 +1,37 @@
+# Демо-пайплайн: IoT → SQS → Fission
+
+## Архитектура
+
+1. **Крон-функция (Fission)**
+   - Парсит данные о погоде с сайта для нескольких городов
+   - Эмулирует IoT-датчики: отправляет данные в IoT-сервис (MQTT/HTTP)
+
+2. **IoT-сервис**
+   - Принимает данные от "датчиков"
+   - Публикует сообщения в очередь (SQS или аналог)
+
+3. **Очередь (SQS)**
+   - Хранит сообщения от IoT
+   - Триггерит Fission-функцию при появлении новых данных (MessageQueue Trigger)
+
+4. **Fission-функция**
+   - Получает данные из очереди
+   - Записывает их в таблицу (PostgreSQL, ClickHouse и т.д.)
+
+## Требования к Fission
+
+- Необходим MQ-триггер (MessageQueue Trigger) для автоматического запуска функции по сообщениям из очереди.
+- Сейчас в Fission есть HTTP, Cron, Event, но нет универсального MQ-триггера.
+- Возможные варианты:
+  - Реализовать внешний watcher (SQS/Kafka/RabbitMQ → invoke HTTP endpoint Fission)
+  - Добавить поддержку MQ-триггера в сам Fission (новый CRD + контроллер)
+
+## Примечания
+
+- Все компоненты связаны через API/очереди, каждый слой изолирован.
+- Такой пайплайн типовой для облачных платформ и легко масштабируется.
+- Для MVP достаточно watcher-а очереди, который вызывает функцию через HTTP.
+
+---
+
+Если потребуется — расписать детальный план интеграции или примеры кода для каждого этапа.

python-env/Dockerfile

@@ -1,2 +1,3 @@
 FROM ghcr.io/fission/python-env:latest
+RUN pip install --no-cache-dir boto3==1.34.0 requests==2.31.0 psycopg2-binary==2.9.9
 COPY server.py /app/server.py

sqs-consumer/Dockerfile

@@ -0,0 +1,16 @@
+# Dockerfile для sqs-consumer
+# Назначение: поллит SQS-совместимую очередь (shared-sqs) и вызывает Fission-функцию.
+# Образ: naeel/sqs-consumer:v1.0
+# 2026-05-11
+
+FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY go.mod ./
+COPY main.go ./
+RUN go mod tidy && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -o sqs-consumer .
+
+FROM gcr.io/distroless/static:nonroot
+WORKDIR /
+COPY --from=builder /app/sqs-consumer .
+USER 65532:65532
+ENTRYPOINT ["/sqs-consumer"]

sqs-consumer/go.mod

@@ -0,0 +1,10 @@
+module sqs-consumer
+
+go 1.22
+
+require (
+	github.com/aws/aws-sdk-go-v2 v1.26.1
+	github.com/aws/aws-sdk-go-v2/config v1.27.11
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
+	github.com/aws/aws-sdk-go-v2/service/sqs v1.31.4
+)

sqs-consumer/go.sum

@@ -0,0 +1,28 @@
+github.com/aws/aws-sdk-go-v2 v1.26.1 h1:5554eUqIYVWpU0YmeeYZ0wU64H2VLBs8TlhRB2L+EkA=
+github.com/aws/aws-sdk-go-v2 v1.26.1/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM=
+github.com/aws/aws-sdk-go-v2/config v1.27.11 h1:f47rANd2LQEYHda2ddSCKYId18/8BhSRM4BULGmfgNA=
+github.com/aws/aws-sdk-go-v2/config v1.27.11/go.mod h1:SMsV78RIOYdve1vf36z8LmnszlRWkwMQtomCAI0/mIE=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHHvIq0l/pX3fwO+Tzs=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 h1:FVJ0r5XTHSmIHJV6KuDmdYhEpvlHpiSd38RQWhut5J4=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1/go.mod h1:zusuAeqezXzAB24LGuzuekqMAEgWkVYukBec3kr3jUg=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 h1:aw39xVGeRWlWx9EzGVnhOR4yOjQDHPQ6o6NmBlscyQg=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5/go.mod h1:FSaRudD0dXiMPK2UjknVwwTYyZMRsHv3TtkabsZih5I=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 h1:PG1F3OD1szkuQPzDw3CIQsRIrtTlUC3lP84taWzHlq0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5/go.mod h1:jU1li6RFryMz+so64PpKtudI+QzbKoIEivqdf6LNpOc=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 h1:Ji0DY1xUsUr3I8cHps0G+XM3WWU16lP6yG8qu1GAZAs=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2/go.mod h1:5CsjAbs3NlGQyZNFACh+zztPDI7fU6eW9QsxjfnuBKg=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 h1:ogRAwT1/gxJBcSWDMZlgyFUM962F51A5CRhDLbxLdmo=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7/go.mod h1:YCsIZhXfRPLFFCl5xxY+1T9RKzOKjCut+28JSX2DnAk=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.31.4 h1:mE2ysZMEeQ3ulHWs4mmc4fZEhOfeY1o6QXAfDqjbSgw=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.31.4/go.mod h1:lCN2yKnj+Sp9F6UzpoPPTir+tSaC9Jwf6LcmTqnXFZw=
+github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 h1:vN8hEbpRnL7+Hopy9dzmRle1xmDc7o8tmY0klsr175w=
+github.com/aws/aws-sdk-go-v2/service/sso v1.20.5/go.mod h1:qGzynb/msuZIE8I75DVRCUXw3o3ZyBmUvMwQ2t/BrGM=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2KCuY61kzoCpvtvJJBtOE=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4/go.mod h1:mUYPBhaF2lGiukDEjJX2BLRRKTmoUSitGDUgM4tRxak=
+github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 h1:cwIxeBttqPN3qkaAjcEcsh8NYr8n2HZPkcKgPAi1phU=
+github.com/aws/aws-sdk-go-v2/service/sts v1.28.6/go.mod h1:FZf1/nKNEkHdGGJP/cI2MoIMquumuRK6ol3QQJNDxmw=
+github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q=
+github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E=

sqs-consumer/main.go

@@ -0,0 +1,256 @@
+// sqs-consumer — SQS poller → Fission function invoker
+//
+// Env vars:
+//   SQS_ENDPOINT       — URL SQS сервиса
+//   SQS_QUEUE_NAME     — имя очереди (обязательно)
+//   SQS_ACCESS_KEY     — AccessKeyId тенанта
+//   SQS_SECRET_KEY     — SecretAccessKey тенанта
+//   SQS_REGION         — регион (default: us-east-1)
+//   FUNCTION_URL       — полный URL функции
+//   ROUTER_USERNAME    — логин для /auth/login роутера (optional)
+//   ROUTER_PASSWORD    — пароль для /auth/login роутера (optional)
+//   ROUTER_LOGIN_URL   — URL /auth/login (default: выводится из FUNCTION_URL)
+//   AUTH_TOKEN         — статичный Bearer токен (если ROUTER_USERNAME не задан)
+//   POLL_INTERVAL      — интервал поллинга в секундах (default: 5)
+//   MAX_MESSAGES       — макс. сообщений за раз (default: 1)
+//   MAX_RETRIES        — попыток вызова функции перед skip (default: 3)
+//
+// 2026-05-12
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	awsconfig "github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+)
+
+// tokenManager управляет JWT токеном с автообновлением.
+type tokenManager struct {
+	mu          sync.Mutex
+	client      *http.Client
+	loginURL    string
+	username    string
+	password    string
+	staticToken string
+	cached      string
+	expiresAt   time.Time
+}
+
+func newTokenManager(client *http.Client, functionURL, loginURL, username, password, staticToken string) *tokenManager {
+	if loginURL == "" && username != "" {
+		if i := strings.Index(functionURL, "://"); i >= 0 {
+			rest := functionURL[i+3:]
+			if j := strings.Index(rest, "/"); j >= 0 {
+				loginURL = functionURL[:i+3] + rest[:j] + "/auth/login"
+			} else {
+				loginURL = functionURL + "/auth/login"
+			}
+		}
+	}
+	return &tokenManager{
+		client:      client,
+		loginURL:    loginURL,
+		username:    username,
+		password:    password,
+		staticToken: staticToken,
+	}
+}
+
+func (tm *tokenManager) getToken(log *slog.Logger) string {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	if tm.username == "" {
+		return tm.staticToken
+	}
+	if tm.cached != "" && time.Now().Add(30*time.Second).Before(tm.expiresAt) {
+		return tm.cached
+	}
+	token, exp := tm.login(log)
+	if token != "" {
+		tm.cached = token
+		tm.expiresAt = exp
+		log.Info("router token refreshed", "expiresAt", exp)
+	}
+	return tm.cached
+}
+
+func (tm *tokenManager) login(log *slog.Logger) (string, time.Time) {
+	body, _ := json.Marshal(map[string]string{"username": tm.username, "password": tm.password})
+	resp, err := tm.client.Post(tm.loginURL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		log.Error("router login failed", "err", err)
+		return "", time.Time{}
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		log.Error("router login non-2xx", "status", resp.StatusCode)
+		return "", time.Time{}
+	}
+	var result struct {
+		AccessToken string `json:"accesstoken"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil || result.AccessToken == "" {
+		log.Error("router login decode failed", "err", err)
+		return "", time.Time{}
+	}
+	return result.AccessToken, time.Now().Add(5 * time.Minute)
+}
+
+func (tm *tokenManager) invalidate() {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+	tm.cached = ""
+}
+
+func main() {
+	log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+
+	endpoint := getenv("SQS_ENDPOINT", "http://shared-sqs.shared-sqs.svc.cluster.local:4100")
+	queueName := mustenv("SQS_QUEUE_NAME")
+	accessKey := mustenv("SQS_ACCESS_KEY")
+	secretKey := mustenv("SQS_SECRET_KEY")
+	region := getenv("SQS_REGION", "us-east-1")
+	functionURL := mustenv("FUNCTION_URL")
+	routerUser := getenv("ROUTER_USERNAME", "")
+	routerPass := getenv("ROUTER_PASSWORD", "")
+	routerLoginURL := getenv("ROUTER_LOGIN_URL", "")
+	staticToken := getenv("AUTH_TOKEN", "")
+	pollSec := parseInt(getenv("POLL_INTERVAL", "5"), 5)
+	maxMsg := int32(parseInt(getenv("MAX_MESSAGES", "1"), 1))
+	maxRetries := parseInt(getenv("MAX_RETRIES", "3"), 3)
+
+	customResolver := aws.EndpointResolverWithOptionsFunc(
+		func(service, reg string, opts ...interface{}) (aws.Endpoint, error) {
+			return aws.Endpoint{URL: endpoint, HostnameImmutable: true}, nil
+		},
+	)
+	cfg, err := awsconfig.LoadDefaultConfig(context.Background(),
+		awsconfig.WithRegion(region),
+		awsconfig.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
+		awsconfig.WithEndpointResolverWithOptions(customResolver),
+	)
+	if err != nil {
+		log.Error("failed to create AWS config", "err", err)
+		os.Exit(1)
+	}
+
+	client := sqs.NewFromConfig(cfg)
+	ctx := context.Background()
+	urlResult, err := client.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{QueueName: aws.String(queueName)})
+	if err != nil {
+		log.Error("GetQueueUrl failed", "queue", queueName, "err", err)
+		os.Exit(1)
+	}
+	queueURL := aws.ToString(urlResult.QueueUrl)
+	log.Info("sqs-consumer started", "queue", queueName, "endpoint", endpoint, "functionURL", functionURL)
+
+	httpClient := &http.Client{Timeout: 30 * time.Second}
+	tm := newTokenManager(httpClient, functionURL, routerLoginURL, routerUser, routerPass, staticToken)
+
+	ticker := time.NewTicker(time.Duration(pollSec) * time.Second)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		poll(ctx, log, client, httpClient, tm, queueURL, functionURL, maxMsg, maxRetries)
+	}
+}
+
+func poll(ctx context.Context, log *slog.Logger, sqsClient *sqs.Client, httpClient *http.Client,
+	tm *tokenManager, queueURL, functionURL string, maxMsg int32, maxRetries int) {
+
+	result, err := sqsClient.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
+		QueueUrl:            aws.String(queueURL),
+		MaxNumberOfMessages: maxMsg,
+		WaitTimeSeconds:     5,
+	})
+	if err != nil {
+		log.Error("SQS ReceiveMessage failed", "err", err)
+		return
+	}
+
+	for _, msg := range result.Messages {
+		body := aws.ToString(msg.Body)
+		receipt := aws.ToString(msg.ReceiptHandle)
+		if invokeWithRetry(log, httpClient, tm, functionURL, body, maxRetries) {
+			if _, err := sqsClient.DeleteMessage(ctx, &sqs.DeleteMessageInput{
+				QueueUrl:      aws.String(queueURL),
+				ReceiptHandle: aws.String(receipt),
+			}); err != nil {
+				log.Error("DeleteMessage failed", "err", err)
+			} else {
+				log.Info("message processed", "msgId", aws.ToString(msg.MessageId))
+			}
+		}
+	}
+}
+
+func invokeWithRetry(log *slog.Logger, client *http.Client, tm *tokenManager, url, body string, maxRetries int) bool {
+	for attempt := 1; attempt <= maxRetries; attempt++ {
+		token := tm.getToken(log)
+		req, _ := http.NewRequest(http.MethodPost, url, bytes.NewBufferString(body))
+		req.Header.Set("Content-Type", "application/json")
+		if token != "" {
+			req.Header.Set("Authorization", "Bearer "+token)
+		}
+		resp, err := client.Do(req)
+		if err != nil {
+			log.Warn("function invoke error", "attempt", attempt, "err", err)
+			time.Sleep(time.Duration(attempt) * time.Second)
+			continue
+		}
+		io.Copy(io.Discard, resp.Body)
+		resp.Body.Close()
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			return true
+		}
+		if resp.StatusCode == http.StatusUnauthorized {
+			log.Warn("got 401, refreshing token", "attempt", attempt)
+			tm.invalidate()
+		} else {
+			log.Warn("function returned non-2xx", "attempt", attempt, "status", resp.StatusCode)
+		}
+		time.Sleep(time.Duration(attempt) * time.Second)
+	}
+	log.Error("all retries exhausted, skipping message", "url", url)
+	return false
+}
+
+func getenv(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
+
+func mustenv(key string) string {
+	v := os.Getenv(key)
+	if v == "" {
+		fmt.Fprintf(os.Stderr, "ERROR: env var %s is required\n", key)
+		os.Exit(1)
+	}
+	return v
+}
+
+func parseInt(s string, def int) int {
+	n, err := strconv.Atoi(s)
+	if err != nil || n <= 0 {
+		return def
+	}
+	return n
+}

terraform/provider/internal/client/client.go

@@ -4,7 +4,10 @@ import (
 	"context"
 	"fmt"
 
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	k8sresource "k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -38,6 +41,28 @@ var httpTriggerGVR = schema.GroupVersionResource{
 	Resource: "httptriggers",
 }
 
+var timeTriggerGVR = schema.GroupVersionResource{
+	Group:    "fission.io",
+	Version:  "v1",
+	Resource: "timetriggers",
+}
+
+var iotDeviceGVR = schema.GroupVersionResource{
+	Group:    "iot.kube5s.ru",
+	Version:  "v1alpha1",
+	Resource: "iotdevices",
+}
+
+const (
+	sqsConsumerImage   = "naeel/sqs-consumer:v1.0"
+	sqsDefaultEndpoint = "http://shared-sqs.shared-sqs.svc.cluster.local:4100"
+	fissionRouterBase  = "http://router.fission.svc.cluster.local"
+	mqManagedByLabel   = "app.kubernetes.io/managed-by"
+	mqManagedByVal     = "fission-terraform"
+	mqComponentLabel   = "component"
+	mqComponentVal     = "mq-trigger"
+)
+
 // Client хранит клиентов Kubernetes API для работы с CRD Fission.
 type Client struct {
 	DynClient dynamic.Interface
@@ -253,3 +278,242 @@ func (c *Client) DeleteHTTPTrigger(ctx context.Context, namespace, name string)
 
 	return nil
 }
+
+// ── MQ Trigger (K8s Deployment + Secret) ────────────────────────────
+
+func mqSecretName(name string) string { return "sqs-mq-" + name }
+func mqDeployName(name string) string { return "mq-" + name }
+
+// MQTriggerInfo — данные MQ trigger, считанные из K8s.
+type MQTriggerInfo struct {
+	Function    string
+	Queue       string
+	SQSEndpoint string
+	DeployUID   string
+}
+
+// CreateMQTrigger создаёт Secret + Deployment для SQS consumer.
+func (c *Client) CreateMQTrigger(ctx context.Context, name, ns, functionName, queue, sqsEndpoint, accessKey, secretKey string) (*MQTriggerInfo, error) {
+	if sqsEndpoint == "" {
+		sqsEndpoint = sqsDefaultEndpoint
+	}
+	functionURL := fissionRouterBase + "/" + functionName
+	secretName := mqSecretName(name)
+	deployName := mqDeployName(name)
+
+	labels := map[string]string{
+		mqManagedByLabel:  mqManagedByVal,
+		mqComponentLabel:  mqComponentVal,
+		"mq-trigger-name": name,
+	}
+
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{Name: secretName, Namespace: ns, Labels: labels},
+		StringData: map[string]string{
+			"SQS_ACCESS_KEY": accessKey,
+			"SQS_SECRET_KEY": secretKey,
+			"SQS_ENDPOINT":   sqsEndpoint,
+		},
+	}
+	if _, err := c.K8sClient.CoreV1().Secrets(ns).Create(ctx, secret, metav1.CreateOptions{}); err != nil {
+		return nil, fmt.Errorf("create mq secret %q: %w", secretName, err)
+	}
+
+	replicas := int32(1)
+	deploy := &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      deployName,
+			Namespace: ns,
+			Labels:    labels,
+			Annotations: map[string]string{
+				"fission-terraform/mq-trigger-name": name,
+				"fission-terraform/function":        functionName,
+				"fission-terraform/queue":           queue,
+				"fission-terraform/sqs-endpoint":    sqsEndpoint,
+			},
+		},
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &replicas,
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"mq-trigger-name": name}},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{
+					"mq-trigger-name": name,
+					mqComponentLabel:  mqComponentVal,
+				}},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{{
+						Name:            "sqs-consumer",
+						Image:           sqsConsumerImage,
+						ImagePullPolicy: corev1.PullAlways,
+						Env: []corev1.EnvVar{
+							{Name: "SQS_QUEUE_NAME", Value: queue},
+							{Name: "SQS_REGION", Value: "us-east-1"},
+							{Name: "FUNCTION_URL", Value: functionURL},
+							{Name: "POLL_INTERVAL", Value: "5"},
+							{Name: "MAX_MESSAGES", Value: "1"},
+							{Name: "MAX_RETRIES", Value: "3"},
+						},
+						EnvFrom: []corev1.EnvFromSource{{
+							SecretRef: &corev1.SecretEnvSource{
+								LocalObjectReference: corev1.LocalObjectReference{Name: secretName},
+							},
+						}},
+						Resources: corev1.ResourceRequirements{
+							Limits: corev1.ResourceList{
+								corev1.ResourceCPU:    k8sresource.MustParse("50m"),
+								corev1.ResourceMemory: k8sresource.MustParse("32Mi"),
+							},
+							Requests: corev1.ResourceList{
+								corev1.ResourceCPU:    k8sresource.MustParse("10m"),
+								corev1.ResourceMemory: k8sresource.MustParse("16Mi"),
+							},
+						},
+					}},
+				},
+			},
+		},
+	}
+
+	created, err := c.K8sClient.AppsV1().Deployments(ns).Create(ctx, deploy, metav1.CreateOptions{})
+	if err != nil {
+		_ = c.K8sClient.CoreV1().Secrets(ns).Delete(ctx, secretName, metav1.DeleteOptions{})
+		return nil, fmt.Errorf("create mq deployment %q: %w", deployName, err)
+	}
+
+	return &MQTriggerInfo{
+		Function:    functionName,
+		Queue:       queue,
+		SQSEndpoint: sqsEndpoint,
+		DeployUID:   string(created.UID),
+	}, nil
+}
+
+// GetMQTrigger возвращает информацию о MQ trigger по аннотациям Deployment.
+func (c *Client) GetMQTrigger(ctx context.Context, ns, name string) (*MQTriggerInfo, error) {
+	deploy, err := c.K8sClient.AppsV1().Deployments(ns).Get(ctx, mqDeployName(name), metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("get mq deployment %q: %w", name, err)
+	}
+	ann := deploy.Annotations
+	return &MQTriggerInfo{
+		Function:    ann["fission-terraform/function"],
+		Queue:       ann["fission-terraform/queue"],
+		SQSEndpoint: ann["fission-terraform/sqs-endpoint"],
+		DeployUID:   string(deploy.UID),
+	}, nil
+}
+
+// DeleteMQTrigger удаляет Deployment + Secret MQ trigger.
+func (c *Client) DeleteMQTrigger(ctx context.Context, ns, name string) error {
+	dErr := c.K8sClient.AppsV1().Deployments(ns).Delete(ctx, mqDeployName(name), metav1.DeleteOptions{})
+	sErr := c.K8sClient.CoreV1().Secrets(ns).Delete(ctx, mqSecretName(name), metav1.DeleteOptions{})
+	if dErr != nil && !apierrors.IsNotFound(dErr) {
+		return fmt.Errorf("delete mq deployment %q: %w", name, dErr)
+	}
+	if sErr != nil && !apierrors.IsNotFound(sErr) {
+		return fmt.Errorf("delete mq secret %q: %w", name, sErr)
+	}
+	return nil
+}
+
+// ── TimeTrigger (Fission CRD) ────────────────────────────────────────
+
+// CreateTimeTrigger создаёт объект TimeTrigger (CRON) в заданном namespace.
+func (c *Client) CreateTimeTrigger(ctx context.Context, tt *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	created, err := c.DynClient.Resource(timeTriggerGVR).Namespace(tt.GetNamespace()).Create(ctx, tt, metav1.CreateOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("create time trigger %q: %w", tt.GetName(), err)
+	}
+	return created, nil
+}
+
+// GetTimeTrigger возвращает объект TimeTrigger по имени.
+func (c *Client) GetTimeTrigger(ctx context.Context, namespace, name string) (*unstructured.Unstructured, error) {
+	tt, err := c.DynClient.Resource(timeTriggerGVR).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("get time trigger %q: %w", name, err)
+	}
+	return tt, nil
+}
+
+// UpdateTimeTrigger обновляет объект TimeTrigger.
+func (c *Client) UpdateTimeTrigger(ctx context.Context, tt *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	updated, err := c.DynClient.Resource(timeTriggerGVR).Namespace(tt.GetNamespace()).Update(ctx, tt, metav1.UpdateOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("update time trigger %q: %w", tt.GetName(), err)
+	}
+	return updated, nil
+}
+
+// DeleteTimeTrigger удаляет объект TimeTrigger по имени.
+func (c *Client) DeleteTimeTrigger(ctx context.Context, namespace, name string) error {
+	if err := c.DynClient.Resource(timeTriggerGVR).Namespace(namespace).Delete(ctx, name, metav1.DeleteOptions{}); err != nil {
+		return fmt.Errorf("delete time trigger %q: %w", name, err)
+	}
+	return nil
+}
+
+// ── IoTDevice (CRD iot.kube5s.ru/v1alpha1) ──────────────────────────
+
+// IoTDeviceInfo — данные IoTDevice из статуса CRD.
+type IoTDeviceInfo struct {
+	Phase        string
+	MQTTUsername string
+	SecretName   string
+	TopicPrefix  string
+}
+
+// CreateIoTDevice создаёт объект IoTDevice.
+func (c *Client) CreateIoTDevice(ctx context.Context, name, namespace, deviceID string, metadata map[string]string) (*IoTDeviceInfo, error) {
+	obj := &unstructured.Unstructured{
+		Object: map[string]any{
+			"apiVersion": "iot.kube5s.ru/v1alpha1",
+			"kind":       "IoTDevice",
+			"metadata": map[string]any{
+				"name":      name,
+				"namespace": namespace,
+			},
+			"spec": map[string]any{
+				"deviceId": deviceID,
+				"enabled":  true,
+				"metadata": metadata,
+			},
+		},
+	}
+	created, err := c.DynClient.Resource(iotDeviceGVR).Namespace(namespace).Create(ctx, obj, metav1.CreateOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("create iot device %q: %w", name, err)
+	}
+	return extractIoTDeviceInfo(created), nil
+}
+
+// GetIoTDevice возвращает IoTDevice по имени.
+func (c *Client) GetIoTDevice(ctx context.Context, namespace, name string) (*IoTDeviceInfo, error) {
+	obj, err := c.DynClient.Resource(iotDeviceGVR).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("get iot device %q: %w", name, err)
+	}
+	return extractIoTDeviceInfo(obj), nil
+}
+
+// DeleteIoTDevice удаляет IoTDevice по имени.
+func (c *Client) DeleteIoTDevice(ctx context.Context, namespace, name string) error {
+	if err := c.DynClient.Resource(iotDeviceGVR).Namespace(namespace).Delete(ctx, name, metav1.DeleteOptions{}); err != nil {
+		return fmt.Errorf("delete iot device %q: %w", name, err)
+	}
+	return nil
+}
+
+func extractIoTDeviceInfo(obj *unstructured.Unstructured) *IoTDeviceInfo {
+	status, _, _ := unstructured.NestedMap(obj.Object, "status")
+	phase, _ := status["phase"].(string)
+	mqttUsername, _ := status["mqttUsername"].(string)
+	secretName, _ := status["secretName"].(string)
+	topicPrefix, _ := status["topicPrefix"].(string)
+	return &IoTDeviceInfo{
+		Phase:        phase,
+		MQTTUsername: mqttUsername,
+		SecretName:   secretName,
+		TopicPrefix:  topicPrefix,
+	}
+}

terraform/provider/internal/provider/provider.go

@@ -99,6 +99,9 @@ func (p *FissionProvider) Resources(_ context.Context) []func() resource.Resourc
 		resources.NewFunctionResource,
 		resources.NewHTTPTriggerResource,
 		resources.NewSimpleFunctionResource,
+		resources.NewMQTriggerResource,
+		resources.NewCronTriggerResource,
+		resources.NewIoTDeviceResource,
 	}
 }
 

terraform/provider/internal/resources/cron_trigger_resource.go

@@ -0,0 +1,208 @@
+package resources
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+
+	"terraform-provider-fission/internal/client"
+)
+
+var _ resource.Resource = &CronTriggerResource{}
+
+// CronTriggerResource управляет Fission TimeTrigger (CRON).
+type CronTriggerResource struct {
+	client *client.Client
+}
+
+type cronTriggerResourceModel struct {
+	ID        types.String `tfsdk:"id"`
+	Name      types.String `tfsdk:"name"`
+	Namespace types.String `tfsdk:"namespace"`
+	Function  types.String `tfsdk:"function"`
+	Cron      types.String `tfsdk:"cron"`
+	UID       types.String `tfsdk:"uid"`
+}
+
+func NewCronTriggerResource() resource.Resource {
+	return &CronTriggerResource{}
+}
+
+func (r *CronTriggerResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_cron_trigger"
+}
+
+func (r *CronTriggerResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Description: "Fission TimeTrigger — запускает функцию по CRON-расписанию.",
+		Attributes: map[string]schema.Attribute{
+			"id": schema.StringAttribute{
+				Computed:    true,
+				Description: "Идентификатор ресурса (namespace/name).",
+			},
+			"name": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя TimeTrigger.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"namespace": schema.StringAttribute{
+				Optional:    true,
+				Computed:    true,
+				Description: "Kubernetes namespace.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"function": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя Fission Function для запуска.",
+			},
+			"cron": schema.StringAttribute{
+				Required:    true,
+				Description: "CRON-расписание, например \"*/10 * * * *\".",
+			},
+			"uid": schema.StringAttribute{
+				Computed:    true,
+				Description: "UID объекта в Kubernetes.",
+			},
+		},
+	}
+}
+
+func (r *CronTriggerResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+	c, ok := req.ProviderData.(*client.Client)
+	if !ok {
+		resp.Diagnostics.AddError("Неверный тип провайдера", fmt.Sprintf("ожидался *client.Client, получен %T", req.ProviderData))
+		return
+	}
+	r.client = c
+}
+
+func (r *CronTriggerResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var plan cronTriggerResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := plan.Namespace.ValueString()
+	if ns == "" {
+		ns = r.client.Namespace
+	}
+
+	obj := buildTimeTrigger(plan.Name.ValueString(), ns, plan.Function.ValueString(), plan.Cron.ValueString())
+	created, err := r.client.CreateTimeTrigger(ctx, obj)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка создания CRON trigger", err.Error())
+		return
+	}
+
+	plan.ID = types.StringValue(ns + "/" + plan.Name.ValueString())
+	plan.Namespace = types.StringValue(ns)
+	plan.UID = types.StringValue(string(created.GetUID()))
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *CronTriggerResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	var state cronTriggerResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	obj, err := r.client.GetTimeTrigger(ctx, state.Namespace.ValueString(), state.Name.ValueString())
+	if err != nil {
+		if client.IsNotFound(err) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		resp.Diagnostics.AddError("Ошибка чтения CRON trigger", err.Error())
+		return
+	}
+
+	spec, _, _ := unstructured.NestedMap(obj.Object, "spec")
+	if cron, ok := spec["cron"].(string); ok {
+		state.Cron = types.StringValue(cron)
+	}
+	if fnRef, ok := spec["functionref"].(map[string]any); ok {
+		if name, ok := fnRef["name"].(string); ok {
+			state.Function = types.StringValue(name)
+		}
+	}
+	state.UID = types.StringValue(string(obj.GetUID()))
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+}
+
+func (r *CronTriggerResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+	var plan cronTriggerResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	existing, err := r.client.GetTimeTrigger(ctx, plan.Namespace.ValueString(), plan.Name.ValueString())
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка получения CRON trigger для обновления", err.Error())
+		return
+	}
+
+	if err := unstructured.SetNestedField(existing.Object, plan.Cron.ValueString(), "spec", "cron"); err != nil {
+		resp.Diagnostics.AddError("Ошибка обновления cron", err.Error())
+		return
+	}
+	if err := unstructured.SetNestedField(existing.Object, plan.Function.ValueString(), "spec", "functionref", "name"); err != nil {
+		resp.Diagnostics.AddError("Ошибка обновления function", err.Error())
+		return
+	}
+
+	updated, err := r.client.UpdateTimeTrigger(ctx, existing)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка обновления CRON trigger", err.Error())
+		return
+	}
+
+	plan.UID = types.StringValue(string(updated.GetUID()))
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *CronTriggerResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	var state cronTriggerResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	if err := r.client.DeleteTimeTrigger(ctx, state.Namespace.ValueString(), state.Name.ValueString()); err != nil {
+		resp.Diagnostics.AddError("Ошибка удаления CRON trigger", err.Error())
+	}
+}
+
+func buildTimeTrigger(name, ns, functionName, cron string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
+		Object: map[string]any{
+			"apiVersion": "fission.io/v1",
+			"kind":       "TimeTrigger",
+			"metadata": map[string]any{
+				"name":      name,
+				"namespace": ns,
+			},
+			"spec": map[string]any{
+				"cron": cron,
+				"functionref": map[string]any{
+					"type": "name",
+					"name": functionName,
+				},
+			},
+		},
+	}
+}

terraform/provider/internal/resources/iot_device_resource.go

@@ -0,0 +1,230 @@
+package resources
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/booldefault"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/mapdefault"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringdefault"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"terraform-provider-fission/internal/client"
+)
+
+var _ resource.Resource = &IoTDeviceResource{}
+
+// IoTDeviceResource управляет CRD IoTDevice (iot.kube5s.ru/v1alpha1).
+type IoTDeviceResource struct {
+	client *client.Client
+}
+
+type iotDeviceResourceModel struct {
+	ID           types.String `tfsdk:"id"`
+	Name         types.String `tfsdk:"name"`
+	Namespace    types.String `tfsdk:"namespace"`
+	DeviceID     types.String `tfsdk:"device_id"`
+	Enabled      types.Bool   `tfsdk:"enabled"`
+	Metadata     types.Map    `tfsdk:"metadata"`
+	Phase        types.String `tfsdk:"phase"`
+	MQTTUsername types.String `tfsdk:"mqtt_username"`
+	SecretName   types.String `tfsdk:"secret_name"`
+	TopicPrefix  types.String `tfsdk:"topic_prefix"`
+}
+
+func NewIoTDeviceResource() resource.Resource {
+	return &IoTDeviceResource{}
+}
+
+func (r *IoTDeviceResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_iot_device"
+}
+
+func (r *IoTDeviceResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Description: "IoT-устройство, зарегистрированное в платформе sless (CRD iot.kube5s.ru/v1alpha1/IoTDevice).",
+		Attributes: map[string]schema.Attribute{
+			"id": schema.StringAttribute{
+				Computed:    true,
+				Description: "Идентификатор ресурса (namespace/name).",
+			},
+			"name": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя IoTDevice.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"namespace": schema.StringAttribute{
+				Optional:    true,
+				Computed:    true,
+				Default:     stringdefault.StaticString("sless"),
+				Description: "Namespace IoTDevice. По умолчанию sless.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"device_id": schema.StringAttribute{
+				Required:    true,
+				Description: "Уникальный ID устройства внутри namespace (строчные буквы, цифры, дефис).",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"enabled": schema.BoolAttribute{
+				Optional:    true,
+				Computed:    true,
+				Default:     booldefault.StaticBool(true),
+				Description: "Активно ли устройство.",
+			},
+			"metadata": schema.MapAttribute{
+				Optional:    true,
+				Computed:    true,
+				ElementType: types.StringType,
+				Default:     mapdefault.StaticValue(types.MapValueMust(types.StringType, map[string]attr.Value{})),
+				Description: "Произвольные метаданные устройства (модель, локация и т.д.).",
+			},
+			// Computed (заполняет iot-operator)
+			"phase": schema.StringAttribute{
+				Computed:    true,
+				Description: "Текущая фаза: Active, Disabled, Pending, Error.",
+			},
+			"mqtt_username": schema.StringAttribute{
+				Computed:    true,
+				Description: "MQTT username, выданный iot-operator.",
+			},
+			"secret_name": schema.StringAttribute{
+				Computed:    true,
+				Description: "Имя K8s Secret с MQTT credentials.",
+			},
+			"topic_prefix": schema.StringAttribute{
+				Computed:    true,
+				Description: "MQTT topic prefix для публикации.",
+			},
+		},
+	}
+}
+
+func (r *IoTDeviceResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+	c, ok := req.ProviderData.(*client.Client)
+	if !ok {
+		resp.Diagnostics.AddError("Неверный тип провайдера", fmt.Sprintf("ожидался *client.Client, получен %T", req.ProviderData))
+		return
+	}
+	r.client = c
+}
+
+func (r *IoTDeviceResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var plan iotDeviceResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := plan.Namespace.ValueString()
+	meta := map[string]string{}
+	if !plan.Metadata.IsNull() && !plan.Metadata.IsUnknown() {
+		elems := plan.Metadata.Elements()
+		for k, v := range elems {
+			if sv, ok := v.(types.String); ok {
+				meta[k] = sv.ValueString()
+			}
+		}
+	}
+
+	info, err := r.client.CreateIoTDevice(ctx, plan.Name.ValueString(), ns, plan.DeviceID.ValueString(), meta)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка создания IoT device", err.Error())
+		return
+	}
+
+	plan.ID = types.StringValue(ns + "/" + plan.Name.ValueString())
+	plan.Phase = types.StringValue(info.Phase)
+	plan.MQTTUsername = types.StringValue(info.MQTTUsername)
+	plan.SecretName = types.StringValue(info.SecretName)
+	plan.TopicPrefix = types.StringValue(info.TopicPrefix)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *IoTDeviceResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	var state iotDeviceResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	info, err := r.client.GetIoTDevice(ctx, state.Namespace.ValueString(), state.Name.ValueString())
+	if err != nil {
+		if client.IsNotFound(err) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		resp.Diagnostics.AddError("Ошибка чтения IoT device", err.Error())
+		return
+	}
+
+	state.Phase = types.StringValue(info.Phase)
+	state.MQTTUsername = types.StringValue(info.MQTTUsername)
+	state.SecretName = types.StringValue(info.SecretName)
+	state.TopicPrefix = types.StringValue(info.TopicPrefix)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+}
+
+func (r *IoTDeviceResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+	// name/namespace/device_id — RequiresReplace, значит Update только для enabled/metadata.
+	// Для простоты: пересоздаём объект.
+	var plan iotDeviceResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := plan.Namespace.ValueString()
+	name := plan.Name.ValueString()
+
+	if err := r.client.DeleteIoTDevice(ctx, ns, name); err != nil && !client.IsNotFound(err) {
+		resp.Diagnostics.AddError("Ошибка удаления IoT device при обновлении", err.Error())
+		return
+	}
+
+	meta := map[string]string{}
+	if !plan.Metadata.IsNull() && !plan.Metadata.IsUnknown() {
+		elems := plan.Metadata.Elements()
+		for k, v := range elems {
+			if sv, ok := v.(types.String); ok {
+				meta[k] = sv.ValueString()
+			}
+		}
+	}
+
+	info, err := r.client.CreateIoTDevice(ctx, name, ns, plan.DeviceID.ValueString(), meta)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка создания IoT device при обновлении", err.Error())
+		return
+	}
+
+	plan.Phase = types.StringValue(info.Phase)
+	plan.MQTTUsername = types.StringValue(info.MQTTUsername)
+	plan.SecretName = types.StringValue(info.SecretName)
+	plan.TopicPrefix = types.StringValue(info.TopicPrefix)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *IoTDeviceResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	var state iotDeviceResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	if err := r.client.DeleteIoTDevice(ctx, state.Namespace.ValueString(), state.Name.ValueString()); err != nil {
+		resp.Diagnostics.AddError("Ошибка удаления IoT device", err.Error())
+	}
+}

terraform/provider/internal/resources/mq_trigger_resource.go

@@ -0,0 +1,205 @@
+package resources
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringdefault"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"terraform-provider-fission/internal/client"
+)
+
+var _ resource.Resource = &MQTriggerResource{}
+
+// MQTriggerResource управляет MQ-триггером через K8s Deployment+Secret (sqs-consumer).
+type MQTriggerResource struct {
+	client *client.Client
+}
+
+type mqTriggerResourceModel struct {
+	ID          types.String `tfsdk:"id"`
+	Name        types.String `tfsdk:"name"`
+	Namespace   types.String `tfsdk:"namespace"`
+	Function    types.String `tfsdk:"function"`
+	Queue       types.String `tfsdk:"queue"`
+	AccessKey   types.String `tfsdk:"access_key"`
+	SecretKey   types.String `tfsdk:"secret_key"`
+	SQSEndpoint types.String `tfsdk:"sqs_endpoint"`
+}
+
+func NewMQTriggerResource() resource.Resource {
+	return &MQTriggerResource{}
+}
+
+func (r *MQTriggerResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_mq_trigger"
+}
+
+func (r *MQTriggerResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Description: "MQ-триггер через K8s Deployment (sqs-consumer) + Secret с SQS credentials.",
+		Attributes: map[string]schema.Attribute{
+			"id": schema.StringAttribute{
+				Computed:    true,
+				Description: "Идентификатор ресурса (namespace/name).",
+			},
+			"name": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя MQ trigger.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"namespace": schema.StringAttribute{
+				Optional:    true,
+				Computed:    true,
+				Description: "Kubernetes namespace.",
+				PlanModifiers: []planmodifier.String{
+					stringplanmodifier.RequiresReplace(),
+				},
+			},
+			"function": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя Fission Function, к которой направляются сообщения из очереди.",
+			},
+			"queue": schema.StringAttribute{
+				Required:    true,
+				Description: "Имя SQS очереди.",
+			},
+			"access_key": schema.StringAttribute{
+				Required:    true,
+				Sensitive:   true,
+				Description: "SQS Access Key.",
+			},
+			"secret_key": schema.StringAttribute{
+				Required:    true,
+				Sensitive:   true,
+				Description: "SQS Secret Key.",
+			},
+			"sqs_endpoint": schema.StringAttribute{
+				Optional:    true,
+				Computed:    true,
+				Default:     stringdefault.StaticString("http://shared-sqs.shared-sqs.svc.cluster.local:4100"),
+				Description: "SQS endpoint URL. По умолчанию — внутренний shared-sqs.",
+			},
+		},
+	}
+}
+
+func (r *MQTriggerResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+	c, ok := req.ProviderData.(*client.Client)
+	if !ok {
+		resp.Diagnostics.AddError("Неверный тип провайдера", fmt.Sprintf("ожидался *client.Client, получен %T", req.ProviderData))
+		return
+	}
+	r.client = c
+}
+
+func (r *MQTriggerResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var plan mqTriggerResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := plan.Namespace.ValueString()
+	if ns == "" {
+		ns = r.client.Namespace
+	}
+
+	info, err := r.client.CreateMQTrigger(
+		ctx,
+		plan.Name.ValueString(),
+		ns,
+		plan.Function.ValueString(),
+		plan.Queue.ValueString(),
+		plan.SQSEndpoint.ValueString(),
+		plan.AccessKey.ValueString(),
+		plan.SecretKey.ValueString(),
+	)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка создания MQ trigger", err.Error())
+		return
+	}
+
+	plan.ID = types.StringValue(ns + "/" + plan.Name.ValueString())
+	plan.Namespace = types.StringValue(ns)
+	plan.SQSEndpoint = types.StringValue(info.SQSEndpoint)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *MQTriggerResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	var state mqTriggerResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := state.Namespace.ValueString()
+	info, err := r.client.GetMQTrigger(ctx, ns, state.Name.ValueString())
+	if err != nil {
+		if client.IsNotFound(err) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		resp.Diagnostics.AddError("Ошибка чтения MQ trigger", err.Error())
+		return
+	}
+
+	state.Function = types.StringValue(info.Function)
+	state.Queue = types.StringValue(info.Queue)
+	state.SQSEndpoint = types.StringValue(info.SQSEndpoint)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+}
+
+func (r *MQTriggerResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+	var plan mqTriggerResourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ns := plan.Namespace.ValueString()
+	name := plan.Name.ValueString()
+
+	// Удаляем старый и создаём заново с новыми параметрами.
+	if err := r.client.DeleteMQTrigger(ctx, ns, name); err != nil {
+		resp.Diagnostics.AddError("Ошибка удаления MQ trigger при обновлении", err.Error())
+		return
+	}
+	info, err := r.client.CreateMQTrigger(
+		ctx, name, ns,
+		plan.Function.ValueString(),
+		plan.Queue.ValueString(),
+		plan.SQSEndpoint.ValueString(),
+		plan.AccessKey.ValueString(),
+		plan.SecretKey.ValueString(),
+	)
+	if err != nil {
+		resp.Diagnostics.AddError("Ошибка создания MQ trigger при обновлении", err.Error())
+		return
+	}
+
+	plan.SQSEndpoint = types.StringValue(info.SQSEndpoint)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+}
+
+func (r *MQTriggerResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	var state mqTriggerResourceModel
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	if err := r.client.DeleteMQTrigger(ctx, state.Namespace.ValueString(), state.Name.ValueString()); err != nil {
+		resp.Diagnostics.AddError("Ошибка удаления MQ trigger", err.Error())
+	}
+}

token.txt

@@ -1,4 +1,66 @@
 ntazetdinov@nubes.ru
 stxVxLvM9eqssgZ
 
-eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoLWFwaSIsInN1YiI6IjAxOWQ3NmM1LTQyNGMtN2MyYy04OWI3LWUzZjA5OTQ5YTk4ZiIsImV4cCI6MTc5MzA3ODQzOSwiaWF0IjoxNzc3NTI2NDM5LCJqdGkiOiI4MTU1ODNkNy0xZTRkLTRiMmMtOGM5ZS0wZDZmMGU2NmJjNTciLCJhdXRoX3RpbWUiOjAsInR5cCI6IiIsImF6cCI6IiIsInNlc3Npb25fc3RhdGUiOiIiLCJhY3IiOiIiLCJhbGxvd2VkLW9yaWdpbnMiOm51bGwsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6bnVsbH0sInJlc291cmNlX2FjY2VzcyI6eyJhY2NvdW50Ijp7InJvbGVzIjpudWxsfX0sInNjb3BlIjoiIiwic2lkIjoiIiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJuYW1lIjoiIiwiQ2xpZW50SUQiOiJXWjAxMTEyIiwiY29tcGFueV9pZCI6IjhlYzcwYWMwLTU0NmQtNDJhNy04Y2ZmLTMzOWM4ZmI1MWEyMyIsImNvbXBhbnlfbmFtZSI6ItCe0J7QniDCq9Cd0KPQkdCV0KHCuyIsImlkcF91c3JfdWlkIjoiMDE5ZDc2YzUtNDI0Yy03YzJjLTg5YjctZTNmMDk5NDlhOThmIiwibG9naW4iOiJudGF6ZXRkaW5vdkBudWJlcy5ydSIsImZpcnN0bmFtZSI6ItCd0LDQuNC70YwiLCJtaWRkbGVuYW1lIjoi0KTQsNGA0LjRgtC-0LLQuNGHIiwibGFzdG5hbWUiOiLQotCw0LfQtdGC0LTQuNC90L7QsiIsImdyb3VwcyI6bnVsbCwicHJlZmVycmVkX3VzZXJuYW1lIjoiIiwiZ2l2ZW5fbmFtZSI6IiIsImZhbWlseV9uYW1lIjoiIiwiZW1haWwiOiJudGF6ZXRkaW5vdkBudWJlcy5ydSJ9.SaZsKAha45-fvKuJkLHUe_09AFsbH5QpzBVdPnjiEDQGIhl1A3ThgnM-oEh_H6CBXXfnOs2QDczzgCD8K8_tYzZKU1Wgk5lj04YW_fbTI89kHTO5wLtrAht9tFEjzBQZ-kmnG8mUK5tgqyNEjsngdQcfqVWRvneF366TiiRXk_76poUPpXWQmqdgCCKb3wq1rRgWcKDZcUC3JvDpOaqYL40zITZlM855drlJhMut4Gkg-EEk7ZGykl6YCsTRWVjFKGQ-7C-BDU2dkmIWhxzBAkvzzM2kBwvtlczCEDiUin7bXE-F_io89oJUYDzY4yPeHzwREwxCp6x9eD1NAIKKuA
+eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoLWFwaSIsInN1YiI6IjAxOWQ3NmM1LTQyNGMtN2MyYy04OWI3LWUzZjA5OTQ5YTk4ZiIsImV4cCI6MTc5MzA3ODQzOSwiaWF0IjoxNzc3NTI2NDM5LCJqdGkiOiI4MTU1ODNkNy0xZTRkLTRiMmMtOGM5ZS0wZDZmMGU2NmJjNTciLCJhdXRoX3RpbWUiOjAsInR5cCI6IiIsImF6cCI6IiIsInNlc3Npb25fc3RhdGUiOiIiLCJhY3IiOiIiLCJhbGxvd2VkLW9yaWdpbnMiOm51bGwsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6bnVsbH0sInJlc291cmNlX2FjY2VzcyI6eyJhY2NvdW50Ijp7InJvbGVzIjpudWxsfX0sInNjb3BlIjoiIiwic2lkIjoiIiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJuYW1lIjoiIiwiQ2xpZW50SUQiOiJXWjAxMTEyIiwiY29tcGFueV9pZCI6IjhlYzcwYWMwLTU0NmQtNDJhNy04Y2ZmLTMzOWM4ZmI1MWEyMyIsImNvbXBhbnlfbmFtZSI6ItCe0J7QniDCq9Cd0KPQkdCV0KHCuyIsImlkcF91c3JfdWlkIjoiMDE5ZDc2YzUtNDI0Yy03YzJjLTg5YjctZTNmMDk5NDlhOThmIiwibG9naW4iOiJudGF6ZXRkaW5vdkBudWJlcy5ydSIsImZpcnN0bmFtZSI6ItCd0LDQuNC70YwiLCJtaWRkbGVuYW1lIjoi0KTQsNGA0LjRgtC-0LLQuNGHIiwibGFzdG5hbWUiOiLQotCw0LfQtdGC0LTQuNC90L7QsiIsImdyb3VwcyI6bnVsbCwicHJlZmVycmVkX3VzZXJuYW1lIjoiIiwiZ2l2ZW5fbmFtZSI6IiIsImZhbWlseV9uYW1lIjoiIiwiZW1haWwiOiJudGF6ZXRkaW5vdkBudWJlcy5ydSJ9.SaZsKAha45-fvKuJkLHUe_09AFsbH5QpzBVdPnjiEDQGIhl1A3ThgnM-oEh_H6CBXXfnOs2QDczzgCD8K8_tYzZKU1Wgk5lj04YW_fbTI89kHTO5wLtrAht9tFEjzBQZ-kmnG8mUK5tgqyNEjsngdQcfqVWRvneF366TiiRXk_76poUPpXWQmqdgCCKb3wq1rRgWcKDZcUC3JvDpOaqYL40zITZlM855drlJhMut4Gkg-EEk7ZGykl6YCsTRWVjFKGQ-7C-BDU2dkmIWhxzBAkvzzM2kBwvtlczCEDiUin7bXE-F_io89oJUYDzY4yPeHzwREwxCp6x9eD1NAIKKuA
+
+----------- token on VM --------------
+https://deck-api-test.ngcloud.ru/api/v1 - для тест стенда где постгрес, файл с токеном - 
+naeel@naeel-vm:~/terra/sless$ ll test.token
+-rw-r--r-- 1 naeel naeel 998 Feb 28 07:18 test.token
+
+--------------------- pg IoT-PG -----------------------
+users
+JSON объект (раскройте для просмотра)
+
+password:
+BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif
+
+username:
+super
+
+Поля состояния (сгенерированные значения)
+monitoring
+{
+  "resourceMetrics": "https://grafana.ngcloud.ru/d/vzjb4zd/kubernetes-pods?orgId=954&var-namespace=dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5&var-resource_realm=iot-naeel"
+}
+
+users
+{
+  "super": {
+    "role": "ddl_user",
+    "username": "super"
+  }
+}
+
+backups
+{}
+
+databases
+{
+  "sqsdb": {
+    "dbName": "sqsdb",
+    "dbOwner": "super"
+  }
+}
+
+externalConnect
+{
+  "slave": {
+    "ip": "",
+    "fqdn": "",
+    "uuid": "",
+    "isExternal": false
+  },
+  "master": {
+    "ip": "",
+    "fqdn": "",
+    "uuid": "",
+    "isExternal": false
+  }
+}
+
+internalConnect
+{
+  "slave": "",
+  "master": "postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local"
+}