# Verificar que el clúster está accesible
kubectl cluster-info

# Verificar la versión de Helm
helm version --short

# Añadir el repositorio de Helm de Fission
helm repo add fission-charts https://fission.github.io/fission-charts/
helm repo update

# Crear el namespace para Fission
kubectl create namespace fission

# Instalar Fission (versión estable)
helm install fission fission-charts/fission-all \
  --namespace fission \
  --set serviceType=LoadBalancer \
  --set routerServiceType=LoadBalancer \
  --version 1.20.0

# Verificar que todos los pods están en ejecución
kubectl get pods -n fission

# Esperar a que los despliegues estén listos
kubectl rollout status deployment/controller -n fission
kubectl rollout status deployment/router -n fission
kubectl rollout status deployment/executor -n fission

# Instalación con opciones adicionales para producción
helm install fission fission-charts/fission-all \
  --namespace fission \
  --set serviceType=LoadBalancer \
  --set routerServiceType=LoadBalancer \
  --set persistence.enabled=true \
  --set persistence.storageClass=standard \
  --set logger.influxdbAdmin.password=TuPasswordSeguro \
  --version 1.20.0

# Descargar el CLI de Fission para Linux
curl -Lo fission https://github.com/fission/fission/releases/download/v1.20.0/fission-v1.20.0-linux-amd64

# Dar permisos de ejecución y mover al PATH
chmod +x fission
sudo mv fission /usr/local/bin/

# En macOS
curl -Lo fission https://github.com/fission/fission/releases/download/v1.20.0/fission-v1.20.0-darwin-amd64
chmod +x fission && sudo mv fission /usr/local/bin/

# Verificar la instalación del CLI
fission version

# Configurar la URL del servidor de Fission
export FISSION_ROUTER=$(kubectl get svc router -n fission -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "Router Fission: $FISSION_ROUTER"

# Listar los entornos disponibles
fission env list

# Crear un entorno Python
fission env create \
  --name python \
  --image fission/python-env:latest \
  --builder fission/python-builder:latest

# Crear un entorno Node.js
fission env create \
  --name nodejs \
  --image fission/node-env:latest \
  --builder fission/node-builder:latest

# Crear un entorno Go
fission env create \
  --name go \
  --image fission/go-env-1.22:latest \
  --builder fission/go-builder-1.22:latest

# Crear entorno con pool de pods precalentados (reduce cold start)
fission env create \
  --name python-pool \
  --image fission/python-env:latest \
  --poolsize 3 \
  --minscale 1 \
  --maxscale 10

# Ver detalles de un entorno
fission env get --name python

# Crear el archivo de la función
cat > hola.py << 'EOF'
def main():
    return "¡Hola desde Fission!"
EOF

# Crear la función en Fission usando el entorno Python
fission fn create \
  --name hola-python \
  --env python \
  --code hola.py

# Probar la función directamente
fission fn test --name hola-python

# Crear una función con dependencias externas
mkdir mi-funcion && cd mi-funcion

cat > handler.py << 'EOF'
import requests

def main():
    # Obtener datos de una API externa
    resp = requests.get("https://api.coindesk.com/v1/bpi/currentprice.json")
    data = resp.json()
    precio = data["bpi"]["USD"]["rate"]
    return f"Bitcoin: ${precio} USD"
EOF

cat > requirements.txt << 'EOF'
requests==2.31.0
EOF

# Empaquetar la función con sus dependencias
zip -r funcion.zip handler.py requirements.txt

# Crear un package en Fission
fission package create \
  --name bitcoin-pkg \
  --env python \
  --sourcearchive funcion.zip \
  --buildcmd "pip install -r requirements.txt -t ."

# Esperar a que el package se construya
fission package info --name bitcoin-pkg

# Crear la función usando el package
fission fn create \
  --name bitcoin-precio \
  --env python \
  --pkg bitcoin-pkg \
  --entrypoint handler.main

cd ..

cat > index.js << 'EOF'
// Función serverless en Node.js
module.exports = async function(context) {
    const nombre = context.request.query.nombre || "Mundo";
    return {
        status: 200,
        body: `¡Hola, ${nombre}! Desde Fission Node.js`
    };
}
EOF

fission fn create \
  --name hola-node \
  --env nodejs \
  --code index.js

# Crear un trigger HTTP para la función Python
fission httptrigger create \
  --name api-hola \
  --url /hola \
  --method GET \
  --function hola-python

# Trigger con múltiples métodos HTTP
fission httptrigger create \
  --name api-usuarios \
  --url /usuarios/{id} \
  --method GET \
  --function obtener-usuario

# Trigger para POST con prefijo de ruta
fission httptrigger create \
  --name api-crear \
  --url /usuarios \
  --method POST \
  --function crear-usuario

# Listar todos los triggers HTTP
fission httptrigger list

# Probar el trigger HTTP
curl "http://$FISSION_ROUTER/hola"
curl "http://$FISSION_ROUTER/usuarios/123"

# Función para la tarea programada
cat > tarea-diaria.py << 'EOF'
import datetime

def main():
    ahora = datetime.datetime.now().isoformat()
    print(f"Tarea ejecutada a las: {ahora}")
    # Aquí iría la lógica de limpieza, reportes, etc.
    return f"Tarea completada: {ahora}"
EOF

fission fn create \
  --name tarea-diaria \
  --env python \
  --code tarea-diaria.py

# Crear un trigger que se ejecute cada día a las 2:00 AM
fission timetrigger create \
  --name limpieza-diaria \
  --function tarea-diaria \
  --cron "0 2 * * *"

# Trigger cada 5 minutos (para monitoreo)
fission timetrigger create \
  --name health-check \
  --function verificar-salud \
  --cron "*/5 * * * *"

# Listar triggers de temporizador
fission timetrigger list

# Instalar NATS en el clúster
helm repo add nats https://nats-io.github.io/k8s/helm/charts/
helm install nats nats/nats --namespace fission

# Función que procesa mensajes
cat > procesar-mensaje.py << 'EOF'
import json

def main(context):
    # El mensaje llega en el cuerpo de la petición
    mensaje = context.request.get_data(as_text=True)
    datos = json.loads(mensaje)
    print(f"Procesando evento: {datos}")
    return "Procesado"
EOF

fission fn create \
  --name procesar-evento \
  --env python \
  --code procesar-mensaje.py

# Crear trigger de mensajería con NATS
fission mqtrigger create \
  --name eventos-nats \
  --function procesar-evento \
  --mqtype nats-streaming \
  --topic eventos.nuevos \
  --resptopic eventos.procesados \
  --errortopic eventos.errores \
  --maxretries 3 \
  --cooldown 30s

# Listar triggers de mensajería
fission mqtrigger list

# Instalar Fission Workflows
helm install fission-workflows fission-charts/fission-workflows \
  --namespace fission

# Ejemplo de workflow en YAML
cat > mi-workflow.yaml << 'EOF'
apiVersion: 1
output: formatear-resultado
tasks:
  obtener-datos:
    run: obtener-datos-fn
    inputs:
      url: "{$.invocation.inputs.default}"

  procesar:
    run: procesar-datos-fn
    inputs:
      datos: "{$.tasks.obtener-datos.output}"
    requires:
      - obtener-datos

  formatear-resultado:
    run: formatear-fn
    inputs:
      resultado: "{$.tasks.procesar.output}"
    requires:
      - procesar
EOF

# Crear el workflow
fission fn create \
  --name mi-pipeline \
  --env workflow \
  --code mi-workflow.yaml

# Ejecutar el workflow
fission fn test --name mi-pipeline --body '{"url": "https://api.ejemplo.com/datos"}'

# Configurar el pool de entornos para reducir cold start
fission env update \
  --name python \
  --poolsize 5 \
  --minscale 2 \
  --maxscale 20

# Configurar recursos por función
fission fn update \
  --name mi-funcion \
  --requestcpu 100m \
  --limitcpu 500m \
  --requestmemory 128Mi \
  --limitmemory 512Mi

# Ver métricas del router
kubectl top pods -n fission -l svc=router

# Ver logs del executor para diagnosticar tiempos de arranque
kubectl logs -n fission deployment/executor --tail=50

# Ver los logs de la función
fission fn logs --name nombre-funcion

# Ver los logs del executor
kubectl logs -n fission deployment/executor

# Probar la función con verbose
fission fn test --name nombre-funcion --verbosity 2

# Ver el estado del package
fission package info --name nombre-package

# Ver los logs del builder
kubectl logs -n fission -l environmentName=python -c builder

# Verificar que el trigger existe
fission httptrigger list

# Verificar la URL del router
echo $FISSION_ROUTER

# Ver los logs del router
kubectl logs -n fission deployment/router --tail=100