mirror of
https://github.com/dredx/prole.git
synced 2026-09-24 19:14:33 +00:00
5e0a1bda85
- Makefile: Added 'init' and 'deploy' targets for k3s parity and Gitea staging. - OpenTofu: Fixed namespace handling in k3s main.tf to prevent metadata overwrites. - UI: Added 'GitOps' and 'Database Options' configuration screens. - Core: Enhanced monitoring, milestones, and environment handling for new services. - Supabase: Integrated full Helm chart and manifest rendering logic. - Gitea: Added deployment scripts and GitOps sync support. - Database: Added Percona/Postgres Dockerfile templates and improved TDE scripts. - Tests: Added coverage for new UI screens and navigation flows.
1211 lines
34 KiB
Bash
Executable File
1211 lines
34 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
|
|
if [[ -f "$PROJECT_ROOT/env.sh" ]]; then
|
|
# shellcheck disable=SC1090
|
|
source "$PROJECT_ROOT/env.sh"
|
|
fi
|
|
|
|
MODE="k3d"
|
|
HELM_RELEASE="supabase"
|
|
USE_DEV_HELPERS="false"
|
|
FOREGROUND="false"
|
|
FORCE="true"
|
|
PROLE_CFG_PATH=""
|
|
HELM_TEMPLATE_ONLY="false"
|
|
|
|
usage() {
|
|
cat <<'USAGE'
|
|
Prole::Supabase
|
|
|
|
Launches the full Supabase open-source stack locally, following the
|
|
README/DEVELOPERS guidance (Docker Compose). This is a multi-service deployment
|
|
(Postgres, Auth, Storage, Realtime, Kong, Studio, etc.)
|
|
|
|
Usage:
|
|
./deploy.sh [options]
|
|
|
|
Options:
|
|
--mode <local|k3d|k8s> Deployment mode ('local' for Docker Compose, 'k3d' for local k3d, 'k8s' for generic k8s/k3s; default: k3d)
|
|
--helm-template-only Render Helm manifests to supabase/k8s without applying (for pipelines)
|
|
--with-dev-helpers Include docker/dev/docker-compose.dev.yml
|
|
--foreground Run docker compose in the foreground (default: detached, local mode only)
|
|
-f, --force Reset the Supabase namespace before applying manifests (k3d only; default)
|
|
--no-force Skip namespace reset (k3d only)
|
|
-c, --config <path> Path to prole.cfg (loads environment defaults)
|
|
-h, --help Show help
|
|
|
|
Notes:
|
|
- This script syncs the Supabase repo into $DEV_HOME/supabase.
|
|
- The deployment runs as a single "supabase" namespace via the Compose project name.
|
|
- For k3d mode, manifests are applied from $SUPABASE_K8S_DIR.
|
|
- Docker image artifacts are cached in $DOCKER_IMPORT_DIR.
|
|
- This script preserves the README/DEVELOPERS steps:
|
|
1) use docker/docker-compose.yml
|
|
2) copy docker/.env.example -> docker/.env (if missing)
|
|
3) run docker compose up
|
|
USAGE
|
|
}
|
|
|
|
die() {
|
|
echo "Error: $*" >&2
|
|
exit 1
|
|
}
|
|
|
|
warn() {
|
|
echo "Warning: $*" >&2
|
|
}
|
|
|
|
log() {
|
|
echo "==> $*"
|
|
}
|
|
|
|
apply_defaults() {
|
|
DEV_HOME="${DEV_HOME:-$HOME/dev}"
|
|
DEV_HOME="${DEV_HOME/#\~/$HOME}"
|
|
SUPABASE_DIR="$DEV_HOME/supabase"
|
|
DOCKER_DIR="$SUPABASE_DIR/docker"
|
|
COMPOSE_FILE="$DOCKER_DIR/docker-compose.yml"
|
|
DEV_COMPOSE_FILE="$DOCKER_DIR/dev/docker-compose.dev.yml"
|
|
ENV_EXAMPLE="$DOCKER_DIR/.env.example"
|
|
ENV_FILE="$DOCKER_DIR/.env"
|
|
SUPABASE_K8S_DIR="${SUPABASE_K8S_DIR:-$SCRIPT_DIR/../build/supabase-k8s}"
|
|
local default_owner
|
|
default_owner="$(id -un 2>/dev/null || echo prole)"
|
|
local data_root="${PROLE_DATA:-/opt/prole/data/${default_owner}}"
|
|
data_root="${data_root%/}"
|
|
DOCKER_IMPORT_DIR="${DOCKER_IMPORT_DIR:-$data_root/docker-import}"
|
|
SUPABASE_IMAGE_PLATFORM="${SUPABASE_IMAGE_PLATFORM:-}"
|
|
SUPABASE_IMAGE_PLATFORMS="${SUPABASE_IMAGE_PLATFORMS:-linux/amd64 linux/arm64}"
|
|
SUPABASE_POSTGRES_PORT="${SUPABASE_POSTGRES_PORT:-15432}"
|
|
PROLE_DB_SERVICE="${PROLE_DB_SERVICE:-prole-db-rw}"
|
|
PROLE_DB_NAMESPACE="${PROLE_DB_NAMESPACE:-}"
|
|
}
|
|
|
|
load_prole_cfg() {
|
|
local cfg_loader="$PROJECT_ROOT/etc/prole_cfg.sh"
|
|
local cfg_path="${PROLE_CFG_PATH:-}"
|
|
|
|
if [[ -z "$cfg_path" ]]; then
|
|
if [[ -n "${PROLE_CONF:-}" ]]; then
|
|
cfg_path="${PROLE_CONF%/}/prole.cfg"
|
|
elif [[ -f "$PROJECT_ROOT/conf/prole.cfg" ]]; then
|
|
cfg_path="$PROJECT_ROOT/conf/prole.cfg"
|
|
fi
|
|
fi
|
|
|
|
if [[ -z "$cfg_path" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
if [[ -n "$cfg_path" ]]; then
|
|
if [[ -d "$cfg_path" ]]; then
|
|
cfg_path="$cfg_path/prole.cfg"
|
|
fi
|
|
[[ -f "$cfg_path" ]] || die "Config file not found: $cfg_path"
|
|
PROLE_CONF="$(cd "$(dirname "$cfg_path")" && pwd)"
|
|
export PROLE_CONF
|
|
PROLE_CFG_PATH="$cfg_path"
|
|
fi
|
|
|
|
if [[ -f "$cfg_loader" ]]; then
|
|
# shellcheck disable=SC1090
|
|
source "$cfg_loader"
|
|
else
|
|
warn "prole_cfg.sh not found; config defaults may be incomplete."
|
|
fi
|
|
}
|
|
|
|
register_supabase_ports() {
|
|
# Register port forwards if helper is available
|
|
if command -v prole_register_port_forward >/dev/null 2>&1; then
|
|
prole_register_port_forward "supabase-kong" "supabase" "svc/kong" "8000" "8000" "0.0.0.0" "TCP" "Supabase API (Kong)"
|
|
prole_register_port_forward "supabase-studio" "supabase" "svc/studio" "8082" "3000" "0.0.0.0" "TCP" "Supabase Studio"
|
|
fi
|
|
}
|
|
|
|
require_cmd() {
|
|
command -v "$1" >/dev/null 2>&1 || die "Missing required command: $1"
|
|
}
|
|
|
|
detect_platform() {
|
|
case "$(uname -m 2>/dev/null || true)" in
|
|
arm64|aarch64) echo "linux/arm64" ;;
|
|
x86_64|amd64) echo "linux/amd64" ;;
|
|
*) echo "linux/amd64" ;;
|
|
esac
|
|
}
|
|
|
|
normalize_platform() {
|
|
case "${1:-}" in
|
|
linux/*) echo "$1" ;;
|
|
arm64|aarch64) echo "linux/arm64" ;;
|
|
x86_64|amd64) echo "linux/amd64" ;;
|
|
"") detect_platform ;;
|
|
*) detect_platform ;;
|
|
esac
|
|
}
|
|
|
|
compose_cmd() {
|
|
if docker compose version >/dev/null 2>&1; then
|
|
echo "docker compose"
|
|
return 0
|
|
fi
|
|
if command -v docker-compose >/dev/null 2>&1; then
|
|
echo "docker-compose"
|
|
return 0
|
|
fi
|
|
die "Docker Compose not found (expected 'docker compose' or 'docker-compose')"
|
|
}
|
|
|
|
ensure_k3d() {
|
|
require_cmd k3d
|
|
}
|
|
|
|
ensure_kompose() {
|
|
require_cmd kompose
|
|
}
|
|
|
|
ensure_helm() {
|
|
require_cmd helm
|
|
}
|
|
|
|
list_k3d_clusters() {
|
|
local json=""
|
|
if json="$(k3d cluster list -o json 2>/dev/null)"; then
|
|
if [[ -n "$json" ]]; then
|
|
if printf '%s' "$json" | python - <<'PY'
|
|
import json
|
|
import sys
|
|
|
|
raw = sys.stdin.read()
|
|
if not raw.strip():
|
|
sys.exit(1)
|
|
try:
|
|
data = json.loads(raw)
|
|
except Exception:
|
|
sys.exit(1)
|
|
|
|
items = data.get("items") if isinstance(data, dict) else data
|
|
if not items:
|
|
sys.exit(0)
|
|
for item in items:
|
|
name = item.get("name") if isinstance(item, dict) else None
|
|
if name:
|
|
print(name)
|
|
PY
|
|
then
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
k3d cluster list 2>/dev/null | awk 'NR>1 {print $1}'
|
|
}
|
|
|
|
cluster_exists() {
|
|
local name="$1"
|
|
list_k3d_clusters | awk -v target="$name" '$0 == target {found=1} END {exit found ? 0 : 1}'
|
|
}
|
|
|
|
ensure_k3d_cluster() {
|
|
local cluster="${K3D_CLUSTER_NAME:-}"
|
|
local -a clusters
|
|
local picked=""
|
|
|
|
mapfile -t clusters < <(list_k3d_clusters || true)
|
|
|
|
if [[ -n "$cluster" ]]; then
|
|
if ! cluster_exists "$cluster"; then
|
|
log "Creating k3d cluster '$cluster'..."
|
|
k3d cluster create "$cluster" >/dev/null
|
|
fi
|
|
picked="$cluster"
|
|
elif [[ ${#clusters[@]} -gt 0 ]]; then
|
|
for name in "${clusters[@]}"; do
|
|
if [[ "$name" == "k3s-default" ]]; then
|
|
picked="$name"
|
|
break
|
|
fi
|
|
done
|
|
if [[ -z "$picked" ]]; then
|
|
picked="${clusters[0]}"
|
|
fi
|
|
else
|
|
picked="k3s-default"
|
|
log "Creating k3d cluster '$picked'..."
|
|
k3d cluster create "$picked" >/dev/null
|
|
fi
|
|
|
|
export K3D_CLUSTER_NAME="$picked"
|
|
log "Using k3d cluster: $K3D_CLUSTER_NAME"
|
|
k3d cluster start "$K3D_CLUSTER_NAME" >/dev/null 2>&1 || true
|
|
k3d kubeconfig merge "$K3D_CLUSTER_NAME" --switch-context >/dev/null 2>&1 || true
|
|
}
|
|
|
|
parse_args() {
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--mode|-m)
|
|
MODE="${2:-}"
|
|
shift 2
|
|
;;
|
|
-c|--config)
|
|
PROLE_CFG_PATH="${2:-}"
|
|
[[ -n "$PROLE_CFG_PATH" ]] || die "Missing value for $1"
|
|
shift 2
|
|
;;
|
|
--config=*)
|
|
PROLE_CFG_PATH="${1#*=}"
|
|
[[ -n "$PROLE_CFG_PATH" ]] || die "Missing value for $1"
|
|
shift
|
|
;;
|
|
--with-dev-helpers)
|
|
USE_DEV_HELPERS="true"
|
|
shift
|
|
;;
|
|
--helm-template-only)
|
|
HELM_TEMPLATE_ONLY="true"
|
|
shift
|
|
;;
|
|
--foreground)
|
|
FOREGROUND="true"
|
|
shift
|
|
;;
|
|
-f|--force)
|
|
FORCE="true"
|
|
shift
|
|
;;
|
|
--no-force)
|
|
FORCE="false"
|
|
shift
|
|
;;
|
|
-h|--help)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
die "Unknown option: $1"
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
ensure_env_file() {
|
|
if [[ -f "$ENV_FILE" ]]; then
|
|
return 0
|
|
fi
|
|
[[ -f "$ENV_EXAMPLE" ]] || die "Missing env example file: $ENV_EXAMPLE"
|
|
log "Creating docker/.env from docker/.env.example"
|
|
cp "$ENV_EXAMPLE" "$ENV_FILE"
|
|
warn "docker/.env contains default secrets. Update them before any production use."
|
|
}
|
|
|
|
compose_files() {
|
|
local -a files=("-f" "docker-compose.yml")
|
|
if [[ "$USE_DEV_HELPERS" == "true" ]]; then
|
|
[[ -f "$DEV_COMPOSE_FILE" ]] || die "Missing dev helpers compose file: $DEV_COMPOSE_FILE"
|
|
files+=("-f" "dev/docker-compose.dev.yml")
|
|
fi
|
|
echo "${files[@]}"
|
|
}
|
|
|
|
ensure_repo() {
|
|
require_cmd git
|
|
mkdir -p "$DEV_HOME"
|
|
if [[ -d "$SUPABASE_DIR/.git" ]]; then
|
|
log "Updating Supabase repo in $SUPABASE_DIR"
|
|
(cd "$SUPABASE_DIR" && git pull)
|
|
return 0
|
|
fi
|
|
if [[ -e "$SUPABASE_DIR" ]]; then
|
|
die "Path exists but is not a git repo: $SUPABASE_DIR"
|
|
fi
|
|
log "Cloning Supabase repo into $SUPABASE_DIR"
|
|
git clone https://github.com/supabase/supabase.git "$SUPABASE_DIR"
|
|
}
|
|
|
|
run_local() {
|
|
ensure_repo
|
|
|
|
[[ -f "$COMPOSE_FILE" ]] || die "Missing compose file: $COMPOSE_FILE"
|
|
|
|
require_cmd docker
|
|
docker info >/dev/null 2>&1 || die "Docker daemon is not running"
|
|
|
|
local compose
|
|
compose="$(compose_cmd)"
|
|
|
|
log "Prole::Supabase local deploy (Docker Compose)"
|
|
log "Repo: $SUPABASE_DIR"
|
|
log "This follows README/DEVELOPERS guidance for running the full open-source stack."
|
|
log "Namespace: supabase (Compose project name)"
|
|
|
|
ensure_env_file
|
|
|
|
local compose_args=("-f" "docker-compose.yml")
|
|
if [[ "$USE_DEV_HELPERS" == "true" ]]; then
|
|
[[ -f "$DEV_COMPOSE_FILE" ]] || die "Missing dev helpers compose file: $DEV_COMPOSE_FILE"
|
|
compose_args+=("-f" "dev/docker-compose.dev.yml")
|
|
fi
|
|
|
|
local up_args=("up")
|
|
if [[ "$FOREGROUND" != "true" ]]; then
|
|
up_args+=("-d")
|
|
fi
|
|
|
|
log "Starting Supabase services..."
|
|
(cd "$DOCKER_DIR" && COMPOSE_PROJECT_NAME="supabase" $compose "${compose_args[@]}" "${up_args[@]}")
|
|
|
|
log "Deployment complete."
|
|
log "Access Studio at http://localhost:8082 (see docker/.env for ports)."
|
|
}
|
|
|
|
image_safe_name() {
|
|
echo "$1" | sed 's/[\/:@]/_/g'
|
|
}
|
|
|
|
image_platform_tag() {
|
|
local img="$1"
|
|
local platform="$2"
|
|
local suffix="${platform//\//-}"
|
|
local name tag
|
|
|
|
if [[ "$img" == *@* ]]; then
|
|
name="${img%@*}"
|
|
tag="digest-${suffix}"
|
|
elif [[ "$img" == *:* ]]; then
|
|
name="${img%:*}"
|
|
tag="${img##*:}-${suffix}"
|
|
else
|
|
name="$img"
|
|
tag="latest-${suffix}"
|
|
fi
|
|
|
|
echo "${name}:${tag}"
|
|
}
|
|
|
|
ensure_image_artifact() {
|
|
local img="$1"
|
|
local platform="$2"
|
|
local safe_name
|
|
local tar_path
|
|
local platform_tag
|
|
|
|
safe_name="$(image_safe_name "$img")"
|
|
tar_path="${DOCKER_IMPORT_DIR}/${safe_name}.${platform//\//-}.tar"
|
|
platform_tag="$(image_platform_tag "$img" "$platform")"
|
|
|
|
if [[ -f "$tar_path" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
mkdir -p "$DOCKER_IMPORT_DIR"
|
|
|
|
# Prefer buildx export to reliably produce single-arch tarballs with containerd-backed Docker
|
|
if docker buildx version >/dev/null 2>&1; then
|
|
log "Fetching image $img for platform $platform (buildx export)"
|
|
if ! printf 'FROM %s\n' "$img" \
|
|
| docker buildx build --pull --platform "$platform" -t "$platform_tag" \
|
|
--output "type=docker,dest=$tar_path" - >/dev/null 2>&1; then
|
|
die "Failed to export image $img ($platform) via buildx"
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
# Fallback: traditional pull + save (may fail on some Docker/containerd combos)
|
|
log "Fetching image $img for platform $platform"
|
|
if ! docker pull --platform "$platform" "$img" >/dev/null 2>&1; then
|
|
if docker image inspect "$img" >/dev/null 2>&1; then
|
|
warn "Using local image for $img (pull failed for $platform)"
|
|
else
|
|
die "Failed to pull image for $img ($platform)"
|
|
fi
|
|
fi
|
|
|
|
docker tag "$img" "$platform_tag" >/dev/null 2>&1 || true
|
|
log "Saving $img ($platform) to $tar_path"
|
|
if ! docker save -o "$tar_path" "$platform_tag" >/dev/null 2>&1; then
|
|
die "Failed to save image $img ($platform) to $tar_path"
|
|
fi
|
|
}
|
|
|
|
load_image_for_platform() {
|
|
local img="$1"
|
|
local platform="$2"
|
|
local safe_name
|
|
local tar_path
|
|
local platform_tag
|
|
|
|
safe_name="$(image_safe_name "$img")"
|
|
tar_path="${DOCKER_IMPORT_DIR}/${safe_name}.${platform//\//-}.tar"
|
|
platform_tag="$(image_platform_tag "$img" "$platform")"
|
|
|
|
if [[ ! -f "$tar_path" ]]; then
|
|
ensure_image_artifact "$img" "$platform"
|
|
fi
|
|
|
|
log "Loading $img ($platform) from $tar_path"
|
|
docker load -i "$tar_path" >/dev/null
|
|
docker tag "$platform_tag" "$img"
|
|
}
|
|
|
|
write_artifact_manifest() {
|
|
local images="$1"
|
|
local list_path="${DOCKER_IMPORT_DIR}/supabase-images.txt"
|
|
|
|
mkdir -p "$DOCKER_IMPORT_DIR"
|
|
printf "%s\n" $images > "$list_path"
|
|
|
|
local platform
|
|
for platform in $SUPABASE_IMAGE_PLATFORMS; do
|
|
local platform_list="${DOCKER_IMPORT_DIR}/supabase-images-${platform//\//-}.txt"
|
|
: > "$platform_list"
|
|
for img in $images; do
|
|
local safe_name
|
|
safe_name="$(image_safe_name "$img")"
|
|
echo "${DOCKER_IMPORT_DIR}/${safe_name}.${platform//\//-}.tar" >> "$platform_list"
|
|
done
|
|
done
|
|
}
|
|
|
|
prefetch_k3d_images() {
|
|
require_cmd docker
|
|
docker info >/dev/null 2>&1 || die "Docker daemon is not running"
|
|
|
|
local compose
|
|
compose="$(compose_cmd)"
|
|
|
|
ensure_env_file
|
|
|
|
local files
|
|
files=($(compose_files))
|
|
|
|
local images
|
|
images=$(cd "$DOCKER_DIR" && $compose "${files[@]}" --env-file ".env" config --images | awk 'NF' | sort -u)
|
|
if [[ -z "$images" ]]; then
|
|
die "No images found in Supabase compose config"
|
|
fi
|
|
|
|
log "Supabase images discovered:"
|
|
printf " - %s\n" $images
|
|
|
|
write_artifact_manifest "$images"
|
|
log "Image artifact list written to $DOCKER_IMPORT_DIR/supabase-images.txt"
|
|
|
|
local platform
|
|
for platform in $SUPABASE_IMAGE_PLATFORMS; do
|
|
log "Ensuring artifacts for platform '$platform' in $DOCKER_IMPORT_DIR"
|
|
for img in $images; do
|
|
ensure_image_artifact "$img" "$platform"
|
|
done
|
|
done
|
|
|
|
local deploy_platform
|
|
deploy_platform="$(normalize_platform "${SUPABASE_IMAGE_PLATFORM:-}")"
|
|
log "Loading images for platform '$deploy_platform'"
|
|
for img in $images; do
|
|
load_image_for_platform "$img" "$deploy_platform"
|
|
done
|
|
|
|
# shellcheck disable=SC2086
|
|
if [[ -n "${K3D_CLUSTER_NAME:-}" ]]; then
|
|
k3d image import $images -c "$K3D_CLUSTER_NAME"
|
|
else
|
|
k3d image import $images
|
|
fi
|
|
}
|
|
|
|
resolve_prole_db_namespace() {
|
|
if [[ -n "${PROLE_DB_NAMESPACE:-}" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
if [[ -n "${NAMESPACE:-}" ]]; then
|
|
PROLE_DB_NAMESPACE="$NAMESPACE"
|
|
return 0
|
|
fi
|
|
|
|
if kubectl get namespace prole >/dev/null 2>&1; then
|
|
PROLE_DB_NAMESPACE="prole"
|
|
else
|
|
PROLE_DB_NAMESPACE="default"
|
|
fi
|
|
}
|
|
|
|
patch_db_deployment_port() {
|
|
local file="$SUPABASE_K8S_DIR/db-deployment.yaml"
|
|
if [[ ! -f "$file" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
local port="$SUPABASE_POSTGRES_PORT"
|
|
python - "$file" "$port" <<'PY'
|
|
import re
|
|
import sys
|
|
|
|
path = sys.argv[1]
|
|
port = sys.argv[2]
|
|
|
|
with open(path, "r", encoding="utf-8") as fh:
|
|
data = fh.read()
|
|
|
|
data = re.sub(r"(name:\s*PGPORT\s*\n\s*value:\s*)\"[^\"]+\"",
|
|
rf"\1\"{port}\"", data)
|
|
data = re.sub(r"(name:\s*POSTGRES_PORT\s*\n\s*value:\s*)\"[^\"]+\"",
|
|
rf"\1\"{port}\"", data)
|
|
|
|
with open(path, "w", encoding="utf-8") as fh:
|
|
fh.write(data)
|
|
PY
|
|
}
|
|
|
|
write_supabase_postgres_service() {
|
|
local file="$SUPABASE_K8S_DIR/supabase-postgres-service.yaml"
|
|
cat > "$file" <<EOF
|
|
apiVersion: v1
|
|
kind: Service
|
|
metadata:
|
|
name: supabase-postgres
|
|
namespace: supabase
|
|
labels:
|
|
app: supabase-postgres
|
|
spec:
|
|
type: ExternalName
|
|
externalName: ${PROLE_DB_SERVICE}.${PROLE_DB_NAMESPACE}.svc.cluster.local
|
|
ports:
|
|
- name: postgres
|
|
port: ${SUPABASE_POSTGRES_PORT}
|
|
targetPort: 5432
|
|
EOF
|
|
}
|
|
|
|
write_db_alias_service() {
|
|
local file="$SUPABASE_K8S_DIR/db-service.yaml"
|
|
|
|
cat > "$file" <<EOF
|
|
apiVersion: v1
|
|
kind: Service
|
|
metadata:
|
|
name: db
|
|
namespace: supabase
|
|
labels:
|
|
app: supabase-db
|
|
spec:
|
|
type: ExternalName
|
|
externalName: ${PROLE_DB_SERVICE}.${PROLE_DB_NAMESPACE}.svc.cluster.local
|
|
ports:
|
|
- name: postgres
|
|
port: 5432
|
|
targetPort: 5432
|
|
EOF
|
|
}
|
|
|
|
|
|
fix_k8s_manifests() {
|
|
log "Post-processing Kubernetes manifests for k8s compatibility..."
|
|
|
|
# 1. Fix db data volume: configMap -> emptyDir (postgres needs writable data dir)
|
|
local db_deploy="$SUPABASE_K8S_DIR/db-deployment.yaml"
|
|
if [[ -f "$db_deploy" ]]; then
|
|
python3 - "$db_deploy" <<'PYFIX'
|
|
import sys, re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
# Replace the db-cm4 configMap volume definition with emptyDir
|
|
# Matches: - configMap:\n name: db-cm4\n name: db-cm4
|
|
content = re.sub(
|
|
r'(\s+)-\s+configMap:\s*\n\s+name:\s*db-cm4\s*\n(\s+name:\s*db-cm4)',
|
|
r'\1- emptyDir: {}\n\2',
|
|
content
|
|
)
|
|
|
|
# Also handle the alternate format kompose might produce
|
|
content = re.sub(
|
|
r'(\s+)-\s+configMap:\s*\n\s+defaultMode:\s*\d+\s*\n\s+name:\s*db-cm4\s*\n(\s+name:\s*db-cm4)',
|
|
r'\1- emptyDir: {}\n\2',
|
|
content
|
|
)
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(f" [OK] db data volume -> emptyDir")
|
|
PYFIX
|
|
fi
|
|
|
|
# 2. Remove db-cm4 configmap (no longer needed; postgres inits its own data dir)
|
|
local db_cm4="$SUPABASE_K8S_DIR/db-cm4-configmap.yaml"
|
|
if [[ -f "$db_cm4" ]]; then
|
|
rm -f "$db_cm4"
|
|
log " Removed db-cm4-configmap.yaml (data dir handled by emptyDir)"
|
|
fi
|
|
|
|
# 3. Scale vector to 0 replicas (docker_logs source needs docker.sock, unavailable in k8s)
|
|
local vector_deploy="$SUPABASE_K8S_DIR/vector-deployment.yaml"
|
|
if [[ -f "$vector_deploy" ]]; then
|
|
python3 - "$vector_deploy" <<'PYFIX'
|
|
import sys, re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
content = re.sub(r'(spec:\s*\n\s+replicas:)\s*\d+', r'\1 0', content, count=1)
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] vector replicas -> 0 (docker_logs incompatible with k8s)")
|
|
PYFIX
|
|
fi
|
|
|
|
# 4. Scale functions to 0 replicas (edge-runtime needs function files not present in k8s)
|
|
local functions_deploy="$SUPABASE_K8S_DIR/functions-deployment.yaml"
|
|
if [[ -f "$functions_deploy" ]]; then
|
|
python3 - "$functions_deploy" <<'PYFIX'
|
|
import sys, re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
content = re.sub(r'(spec:\s*\n\s+replicas:)\s*\d+', r'\1 0', content, count=1)
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] functions replicas -> 0 (edge-runtime entrypoint not available in k8s)")
|
|
PYFIX
|
|
fi
|
|
|
|
|
|
# 6. Scale db deployment to 0 replicas (using prole-db instead of supabase standalone postgres)
|
|
if [[ -f "$db_deploy" ]]; then
|
|
python3 - "$db_deploy" <<'PYFIX'
|
|
import sys, re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
content = re.sub(r'(spec:\s*\n\s+replicas:)\s*\d+', r'\1 0', content, count=1)
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] db replicas -> 0 (using prole-db as database backend)")
|
|
PYFIX
|
|
fi
|
|
|
|
# 7. Fix liveness probes that reference Docker Compose service hostnames
|
|
# In Docker Compose, service names resolve via internal DNS, but in k8s
|
|
# there is no matching Service for every container. Rewrite probes to
|
|
# use localhost (the probe checks the container's own health endpoint).
|
|
local storage_deploy="$SUPABASE_K8S_DIR/storage-deployment.yaml"
|
|
if [[ -f "$storage_deploy" ]]; then
|
|
python3 - "$storage_deploy" <<'PYFIX'
|
|
import sys
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
content = content.replace('http://storage:5000/status', 'http://localhost:5000/status')
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] storage liveness probe -> localhost:5000 (no k8s Service needed)")
|
|
PYFIX
|
|
fi
|
|
|
|
# 8. Fix studio liveness probe: studio:3000 -> localhost:3000
|
|
local studio_deploy="$SUPABASE_K8S_DIR/studio-deployment.yaml"
|
|
if [[ -f "$studio_deploy" ]]; then
|
|
python3 - "$studio_deploy" <<'PYFIX'
|
|
import sys
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
content = content.replace('http://studio:3000/', 'http://localhost:3000/')
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] studio liveness probe -> localhost:3000")
|
|
PYFIX
|
|
fi
|
|
|
|
# 9. Fix realtime liveness probe: kompose emits the whole curl command as a
|
|
# single quoted string instead of a proper argv list. Wrap it in sh -c.
|
|
local realtime_deploy="$SUPABASE_K8S_DIR/realtime-deployment.yaml"
|
|
if [[ -f "$realtime_deploy" ]]; then
|
|
python3 - "$realtime_deploy" <<'PYFIX'
|
|
import sys, re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r') as f:
|
|
content = f.read()
|
|
|
|
# Match the single-string curl command in the exec probe
|
|
m = re.search(
|
|
r"(\s+command:\n)(\s+- )'(curl .+?)'",
|
|
content, re.DOTALL
|
|
)
|
|
if m:
|
|
indent = m.group(2)
|
|
curl_cmd = m.group(3)
|
|
replacement = (
|
|
m.group(1)
|
|
+ indent + "sh\n"
|
|
+ indent + "-c\n"
|
|
+ indent + curl_cmd
|
|
)
|
|
content = content[:m.start()] + replacement + content[m.end():]
|
|
|
|
with open(path, 'w') as f:
|
|
f.write(content)
|
|
print(" [OK] realtime liveness probe -> sh -c curl ...")
|
|
PYFIX
|
|
fi
|
|
}
|
|
|
|
patch_supabase_credentials() {
|
|
log "Patching placeholder credentials in Supabase manifests..."
|
|
|
|
local pg_password=""
|
|
local jwt_secret=""
|
|
|
|
# Resolve postgres password from prole-db-superuser secret
|
|
local ns="${PROLE_DB_NAMESPACE:-prole-db-a0001}"
|
|
if kubectl get secret prole-db-superuser -n "$ns" >/dev/null 2>&1; then
|
|
pg_password=$(kubectl get secret prole-db-superuser -n "$ns" \
|
|
-o jsonpath='{.data.password}' 2>/dev/null | base64 -d 2>/dev/null || true)
|
|
fi
|
|
if [[ -z "$pg_password" ]]; then
|
|
pg_password="${POSTGRES_PASSWORD:-}"
|
|
fi
|
|
|
|
# Resolve JWT secret from supabase-jwt secret or env
|
|
if kubectl get secret supabase-jwt -n supabase >/dev/null 2>&1; then
|
|
jwt_secret=$(kubectl get secret supabase-jwt -n supabase \
|
|
-o jsonpath='{.data.jwt-secret}' 2>/dev/null | base64 -d 2>/dev/null || true)
|
|
fi
|
|
if [[ -z "$jwt_secret" ]]; then
|
|
local env_file="${ENV_FILE:-}"
|
|
if [[ -f "$env_file" ]]; then
|
|
jwt_secret=$(grep -E '^JWT_SECRET=' "$env_file" | head -1 | cut -d= -f2- | tr -d "'\"" || true)
|
|
fi
|
|
fi
|
|
if [[ -z "$jwt_secret" ]]; then
|
|
jwt_secret="${JWT_SECRET:-}"
|
|
fi
|
|
|
|
if [[ -z "$pg_password" ]]; then
|
|
warn "Could not resolve postgres password; manifests will keep placeholder credentials."
|
|
warn "Set POSTGRES_PASSWORD or ensure prole-db-superuser secret exists in namespace '$ns'."
|
|
return 0
|
|
fi
|
|
|
|
# Replace placeholder values in all deployment manifests
|
|
local placeholder_pw="your-super-secret-and-long-postgres-password"
|
|
local placeholder_jwt="your-super-secret-jwt-token-with-at-least-32-characters-long"
|
|
|
|
local f
|
|
for f in "$SUPABASE_K8S_DIR"/*-deployment.yaml; do
|
|
[[ -f "$f" ]] || continue
|
|
python3 - "$f" "$pg_password" "$jwt_secret" "$placeholder_pw" "$placeholder_jwt" <<'PYFIX'
|
|
import sys
|
|
|
|
path = sys.argv[1]
|
|
pg_pw = sys.argv[2]
|
|
jwt_sec = sys.argv[3]
|
|
ph_pw = sys.argv[4]
|
|
ph_jwt = sys.argv[5]
|
|
|
|
with open(path, 'r') as fh:
|
|
content = fh.read()
|
|
|
|
changed = False
|
|
if ph_pw in content and pg_pw:
|
|
content = content.replace(ph_pw, pg_pw)
|
|
changed = True
|
|
if ph_jwt in content and jwt_sec:
|
|
content = content.replace(ph_jwt, jwt_sec)
|
|
changed = True
|
|
|
|
if changed:
|
|
with open(path, 'w') as fh:
|
|
fh.write(content)
|
|
PYFIX
|
|
done
|
|
log " Credentials patched in Supabase manifests."
|
|
}
|
|
|
|
setup_prole_db_for_supabase() {
|
|
log "Ensuring Supabase roles, schemas and databases exist in prole-db..."
|
|
|
|
local ns="${PROLE_DB_NAMESPACE:-prole-db-a0001}"
|
|
|
|
# Find the primary CNPG pod
|
|
local primary
|
|
primary=$(kubectl -n "$ns" get pods \
|
|
-l "cnpg.io/cluster=prole-db,cnpg.io/instanceRole=primary" \
|
|
-o jsonpath='{.items[0].metadata.name}' 2>/dev/null || true)
|
|
if [[ -z "$primary" ]]; then
|
|
primary=$(kubectl -n "$ns" get pods -l "cnpg.io/cluster=prole-db" \
|
|
-o jsonpath='{.items[0].metadata.name}' 2>/dev/null || true)
|
|
fi
|
|
if [[ -z "$primary" ]]; then
|
|
warn "No prole-db pod found in namespace '$ns'; skipping Supabase DB setup."
|
|
return 0
|
|
fi
|
|
|
|
local pg_password=""
|
|
if kubectl get secret prole-db-superuser -n "$ns" >/dev/null 2>&1; then
|
|
pg_password=$(kubectl get secret prole-db-superuser -n "$ns" \
|
|
-o jsonpath='{.data.password}' 2>/dev/null | base64 -d 2>/dev/null || true)
|
|
fi
|
|
if [[ -z "$pg_password" ]]; then
|
|
pg_password="${POSTGRES_PASSWORD:-}"
|
|
fi
|
|
if [[ -z "$pg_password" ]]; then
|
|
warn "Cannot resolve postgres password; skipping Supabase DB role setup."
|
|
return 0
|
|
fi
|
|
|
|
# Create roles required by Supabase services
|
|
kubectl -n "$ns" exec "$primary" -c postgres -- psql -U postgres -d postgres -c "
|
|
-- Core roles
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='anon') THEN CREATE ROLE anon NOLOGIN; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='authenticated') THEN CREATE ROLE authenticated NOLOGIN; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='service_role') THEN CREATE ROLE service_role NOLOGIN; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='authenticator') THEN CREATE ROLE authenticator LOGIN PASSWORD '${pg_password}'; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='pgbouncer') THEN CREATE ROLE pgbouncer LOGIN PASSWORD '${pg_password}'; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='supabase_admin') THEN CREATE ROLE supabase_admin LOGIN PASSWORD '${pg_password}' SUPERUSER; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='supabase_auth_admin') THEN CREATE ROLE supabase_auth_admin LOGIN PASSWORD '${pg_password}' NOINHERIT; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='supabase_storage_admin') THEN CREATE ROLE supabase_storage_admin LOGIN PASSWORD '${pg_password}' NOINHERIT; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='supabase_functions_admin') THEN CREATE ROLE supabase_functions_admin LOGIN PASSWORD '${pg_password}' NOINHERIT; END IF; END \$\$;
|
|
DO \$\$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='supabase_read_only_user') THEN CREATE ROLE supabase_read_only_user NOLOGIN; END IF; END \$\$;
|
|
|
|
-- Grant membership
|
|
GRANT anon TO authenticator;
|
|
GRANT authenticated TO authenticator;
|
|
GRANT service_role TO authenticator;
|
|
GRANT supabase_admin TO authenticator;
|
|
|
|
-- Schemas on postgres database
|
|
CREATE SCHEMA IF NOT EXISTS auth AUTHORIZATION supabase_auth_admin;
|
|
CREATE SCHEMA IF NOT EXISTS storage AUTHORIZATION supabase_storage_admin;
|
|
CREATE SCHEMA IF NOT EXISTS graphql_public;
|
|
CREATE SCHEMA IF NOT EXISTS _realtime;
|
|
ALTER SCHEMA _realtime OWNER TO postgres;
|
|
GRANT USAGE ON SCHEMA public TO anon, authenticated, service_role;
|
|
GRANT USAGE ON SCHEMA auth TO anon, authenticated, service_role;
|
|
GRANT USAGE ON SCHEMA storage TO anon, authenticated, service_role;
|
|
GRANT USAGE ON SCHEMA graphql_public TO anon, authenticated, service_role;
|
|
" 2>&1 || warn "Could not set up Supabase roles (cluster may not be ready yet)."
|
|
|
|
# Create _supabase database (used by supavisor, analytics)
|
|
local db_exists
|
|
db_exists=$(kubectl -n "$ns" exec "$primary" -c postgres -- psql -U postgres -d postgres -tAc \
|
|
"SELECT 1 FROM pg_database WHERE datname = '_supabase';" 2>/dev/null || true)
|
|
if [[ "$db_exists" != "1" ]]; then
|
|
kubectl -n "$ns" exec "$primary" -c postgres -- psql -U postgres -d postgres -c \
|
|
"CREATE DATABASE _supabase OWNER postgres;" 2>&1 || warn "Could not create _supabase database."
|
|
fi
|
|
|
|
# Create schemas in _supabase database
|
|
kubectl -n "$ns" exec "$primary" -c postgres -- psql -U postgres -d _supabase -c "
|
|
CREATE SCHEMA IF NOT EXISTS _supavisor;
|
|
ALTER SCHEMA _supavisor OWNER TO postgres;
|
|
CREATE SCHEMA IF NOT EXISTS _analytics;
|
|
ALTER SCHEMA _analytics OWNER TO postgres;
|
|
" 2>&1 || warn "Could not create _supabase schemas."
|
|
|
|
log " Supabase database roles and schemas ready."
|
|
}
|
|
|
|
generate_k8s_manifests() {
|
|
ensure_kompose
|
|
ensure_env_file
|
|
|
|
local files
|
|
files=($(compose_files))
|
|
|
|
rm -rf "$SUPABASE_K8S_DIR"
|
|
mkdir -p "$SUPABASE_K8S_DIR"
|
|
|
|
log "Generating Kubernetes manifests from docker-compose.yml"
|
|
(cd "$DOCKER_DIR" && kompose "${files[@]}" -n supabase -o "$SUPABASE_K8S_DIR" --volumes=configMap --suppress-warnings convert)
|
|
|
|
fix_k8s_manifests
|
|
resolve_prole_db_namespace
|
|
write_db_alias_service
|
|
patch_db_deployment_port
|
|
write_supabase_postgres_service
|
|
patch_supabase_credentials
|
|
sanitize_container_names
|
|
}
|
|
|
|
sanitize_container_names() {
|
|
log "Sanitizing container names in manifests..."
|
|
local files
|
|
files=("$SUPABASE_K8S_DIR"/*-deployment.yaml)
|
|
for file in "${files[@]}"; do
|
|
[[ -f "$file" ]] || continue
|
|
# Replace dots with hyphens in container names (spec.template.spec.containers[].name)
|
|
python - "$file" <<'PY'
|
|
import sys
|
|
import re
|
|
|
|
path = sys.argv[1]
|
|
with open(path, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
def replace_dots(match):
|
|
prefix = match.group(1)
|
|
name = match.group(2)
|
|
if '.' in name:
|
|
return prefix + name.replace('.', '-')
|
|
return match.group(0)
|
|
|
|
# Match 'name: some.container.name' with at least 4 spaces of indentation
|
|
# This helps avoid metadata.name which usually has 2 spaces.
|
|
new_content = re.sub(r'(\s{4,}name:\s+)([^\n]+)', replace_dots, content)
|
|
|
|
if new_content != content:
|
|
with open(path, 'w', encoding='utf-8') as f:
|
|
f.write(new_content)
|
|
PY
|
|
done
|
|
}
|
|
|
|
helm_render_values() {
|
|
local renderer="$PROJECT_ROOT/supabase/helm/render_supabase.py"
|
|
[[ -f "$renderer" ]] || die "Renderer not found: $renderer"
|
|
|
|
local cfg_arg=()
|
|
if [[ -n "$PROLE_CFG_PATH" ]]; then
|
|
cfg_arg=("-c" "$PROLE_CFG_PATH")
|
|
fi
|
|
|
|
log "Rendering Supabase Helm values/manifests..."
|
|
python3 "$renderer" "${cfg_arg[@]}" \
|
|
--output-dir "$PROJECT_ROOT/supabase/helm/generated" \
|
|
--manifests-dir "$PROJECT_ROOT/supabase/k8s"
|
|
}
|
|
|
|
run_helm() {
|
|
if [[ "$MODE" == "local" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
ensure_helm
|
|
require_cmd kubectl
|
|
kubectl cluster-info >/dev/null 2>&1 || return 1
|
|
|
|
if [[ "$FORCE" == "true" ]]; then
|
|
kubectl delete namespace supabase --ignore-not-found --wait=false >/dev/null 2>&1 || true
|
|
fi
|
|
|
|
helm_render_values
|
|
setup_prole_db_for_supabase
|
|
|
|
local summary="$PROJECT_ROOT/supabase/helm/generated/manifest-summary.json"
|
|
local values="$PROJECT_ROOT/supabase/helm/generated/values.generated.json"
|
|
local ns="supabase"
|
|
if [[ -f "$summary" ]]; then
|
|
ns=$(python3 - "$summary" <<'PY'
|
|
import json, sys
|
|
try:
|
|
path = sys.argv[1]
|
|
data = json.load(open(path))
|
|
print(data.get("supabase_namespace","supabase"))
|
|
except Exception:
|
|
print("supabase")
|
|
PY
|
|
)
|
|
fi
|
|
|
|
if [[ "$HELM_TEMPLATE_ONLY" == "true" ]]; then
|
|
log "Helm template only; manifests ready in supabase/k8s"
|
|
return 0
|
|
fi
|
|
|
|
log "Installing Supabase via Helm into namespace '$ns'..."
|
|
if helm upgrade --install "$HELM_RELEASE" "$PROJECT_ROOT/supabase/helm/prole-supabase" \
|
|
-n "$ns" --create-namespace -f "$values"; then
|
|
register_supabase_ports
|
|
log "Deployment complete via Helm."
|
|
return 0
|
|
else
|
|
warn "Helm install failed; falling back to legacy kompose flow."
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
ensure_supabase_namespace() {
|
|
if ! kubectl get namespace supabase >/dev/null 2>&1; then
|
|
log "Creating 'supabase' namespace..."
|
|
kubectl create namespace supabase
|
|
fi
|
|
}
|
|
|
|
force_reset_supabase_namespace() {
|
|
if ! kubectl get namespace supabase >/dev/null 2>&1; then
|
|
ensure_supabase_namespace
|
|
return
|
|
fi
|
|
|
|
log "Resetting 'supabase' namespace..."
|
|
|
|
# Delete all workloads first to avoid finalizer stalls
|
|
kubectl delete all --all -n supabase --timeout=60s >/dev/null 2>&1 || true
|
|
|
|
# Request namespace deletion without blocking
|
|
kubectl delete namespace supabase --ignore-not-found --wait=false >/dev/null 2>&1 || true
|
|
|
|
if kubectl get namespace supabase >/dev/null 2>&1; then
|
|
if ! kubectl wait --for=delete namespace/supabase --timeout=120s >/dev/null 2>&1; then
|
|
warn "Namespace deletion stalled; clearing finalizers"
|
|
python - <<'PY' | kubectl replace --raw "/api/v1/namespaces/supabase/finalize" -f - >/dev/null 2>&1 || true
|
|
import json
|
|
import subprocess
|
|
import sys
|
|
|
|
try:
|
|
raw = subprocess.check_output(["kubectl", "get", "namespace", "supabase", "-o", "json"])
|
|
if not raw:
|
|
sys.exit(0)
|
|
data = json.loads(raw)
|
|
if "spec" in data:
|
|
data["spec"]["finalizers"] = []
|
|
print(json.dumps(data))
|
|
except Exception:
|
|
sys.exit(0)
|
|
PY
|
|
kubectl wait --for=delete namespace/supabase --timeout=60s >/dev/null 2>&1 || true
|
|
fi
|
|
fi
|
|
|
|
ensure_supabase_namespace
|
|
}
|
|
|
|
run_k3d() {
|
|
# Helm-first path (preferred)
|
|
if run_helm; then
|
|
return 0
|
|
fi
|
|
|
|
ensure_repo
|
|
|
|
log "Prole::Supabase k3d deploy (Kubernetes)"
|
|
log "Repo: $SUPABASE_DIR"
|
|
|
|
require_cmd kubectl
|
|
ensure_k3d
|
|
ensure_k3d_cluster
|
|
kubectl cluster-info >/dev/null 2>&1 || die "Kubernetes cluster not reachable"
|
|
|
|
if [[ "$FORCE" == "true" ]]; then
|
|
force_reset_supabase_namespace
|
|
else
|
|
ensure_supabase_namespace
|
|
fi
|
|
|
|
export SUPABASE_HOME="$SUPABASE_DIR"
|
|
if [[ "$USE_DEV_HELPERS" == "true" ]]; then
|
|
export SUPABASE_USE_DEV_COMPOSE=1
|
|
fi
|
|
export SUPABASE_IMAGE_PLATFORM
|
|
SUPABASE_IMAGE_PLATFORM="$(normalize_platform "${SUPABASE_IMAGE_PLATFORM:-}")"
|
|
|
|
prefetch_k3d_images
|
|
generate_k8s_manifests
|
|
setup_prole_db_for_supabase
|
|
|
|
if [[ -f "$SUPABASE_K8S_DIR/supabase-namespace.yaml" ]]; then
|
|
kubectl apply -f "$SUPABASE_K8S_DIR/supabase-namespace.yaml"
|
|
fi
|
|
|
|
log "Applying Supabase manifests from $SUPABASE_K8S_DIR"
|
|
kubectl apply -f "$SUPABASE_K8S_DIR"
|
|
register_supabase_ports
|
|
|
|
log "Deployment complete."
|
|
log "Access Studio via Kong proxy (check ingress/service in 'supabase' namespace)."
|
|
}
|
|
|
|
run_k8s() {
|
|
# Helm-first path (preferred)
|
|
if run_helm; then
|
|
return 0
|
|
fi
|
|
|
|
ensure_repo
|
|
|
|
log "Prole::Supabase k8s deploy (Kubernetes - generic/containerd)"
|
|
log "Repo: $SUPABASE_DIR"
|
|
|
|
require_cmd kubectl
|
|
kubectl cluster-info >/dev/null 2>&1 || die "Kubernetes cluster not reachable"
|
|
|
|
if [[ "$FORCE" == "true" ]]; then
|
|
force_reset_supabase_namespace
|
|
else
|
|
ensure_supabase_namespace
|
|
fi
|
|
|
|
export SUPABASE_HOME="$SUPABASE_DIR"
|
|
if [[ "$USE_DEV_HELPERS" == "true" ]]; then
|
|
export SUPABASE_USE_DEV_COMPOSE=1
|
|
fi
|
|
|
|
# For generic k8s/k3s clusters (containerd), let nodes pull appropriate arch images directly
|
|
# Optionally, a future enhancement could push pre-fetched images to an internal registry.
|
|
generate_k8s_manifests
|
|
setup_prole_db_for_supabase
|
|
|
|
if [[ -f "$SUPABASE_K8S_DIR/supabase-namespace.yaml" ]]; then
|
|
kubectl apply -f "$SUPABASE_K8S_DIR/supabase-namespace.yaml"
|
|
fi
|
|
|
|
log "Applying Supabase manifests from $SUPABASE_K8S_DIR"
|
|
kubectl apply -f "$SUPABASE_K8S_DIR"
|
|
register_supabase_ports
|
|
|
|
log "Deployment complete."
|
|
log "Access Studio via Kong proxy (check ingress/service in 'supabase' namespace)."
|
|
}
|
|
|
|
main() {
|
|
parse_args "$@"
|
|
load_prole_cfg
|
|
apply_defaults
|
|
|
|
if [[ -z "$MODE" ]]; then
|
|
usage
|
|
exit 1
|
|
fi
|
|
|
|
case "$MODE" in
|
|
local)
|
|
run_local
|
|
;;
|
|
k3d)
|
|
run_k3d
|
|
;;
|
|
k8s)
|
|
run_k8s
|
|
;;
|
|
*)
|
|
die "Unsupported mode: $MODE"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|