Preparación de Recursos en Entorno con Internet

Para realizar una instalación de OpenFaaS en un clúster de Kubernetes sin acceso a internet, primero debemos recopilar todos los artefactos necesarios en una máquina con conectividad.

1. Obtención del Chart de Helm y Manifiestos Base

Comenzamos creando un directorio de trabajo y descargando la versión específica del chart de Helm, así como los espacios de nombres requeridos.

# Definir directorio de trabajo
WORK_DIR="faas_airgap_bundle"
mkdir -p "${WORK_DIR}/"{helm_charts,base_yamls,container_images}

# Agregar el repositorio oficial y descargar el chart
helm repo add faas-netes https://openfaas.github.io/faas-netes/
helm repo update
helm pull faas-netes/openfaas --version 14.2.104 --destination "${WORK_DIR}/helm_charts/"

# Descargar el manifiesto de namespaces
curl -sSL https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml -o "${WORK_DIR}/base_yamls/namespaces.yml"

2. Extracción y Descarga de Imágenes de Contenedores

En lugar de descargar imágenes manualmente, renderizamos el chart para extraer todas las referencias de imágenes y las guardamos en un archivo de texto para su posterior procesamiento.

# Renderizar plantillas y extraer etiquetas de imágenes únicas
helm template "${WORK_DIR}/helm_charts/openfaas-"*.tgz | \
  grep -Eo "image: [a-zA-Z0-9./_:-]+" | \
  awk '{print $2}' | sort -u > "${WORK_DIR}/container_images/required_images.txt"

# Descargar y exportar cada imagen a un archivo tar
while IFS= read -r repo_tag; do
  safe_name=$(echo "${repo_tag}" | tr '/:' '_')
  docker pull "${repo_tag}"
  docker save "${repo_tag}" -o "${WORK_DIR}/container_images/${safe_name}.tar"
done < "${WORK_DIR}/container_images/required_images.txt"

3. Empaquetado y Transferencia

Comprimimos todo el directorio para facilitar su transporte hacia el entorno de producción aislado mediante medios físicos o redes internas seguras.

tar -czvf faas_airgap_bundle.tar.gz -C . faas_airgap_bundle

Configuración del Clúster Aislado

1. Carga de Imágenes en el Registro Interno

Una vez en el servidor destino, descomprimimos el paquete y cargamos las imágenes. Si el clúster utiliza un registro privado (como Harbor o Artifactory), las reetiquetamos y subimos.

tar -xzvf faas_airgap_bundle.tar.gz
cd faas_airgap_bundle

# Cargar imágenes en el daemon de Docker local
for tar_file in container_images/*.tar; do
  docker load -i "${tar_file}"
done

# Opcional: Retiquetar y empujar a un registro privado interno
INTERNAL_REGISTRY="registry.internal.corp:5000"
while IFS= read -r original_image; do
  image_path=$(echo "${original_image}" | sed -E 's/^[^/]+//')
  target_image="${INTERNAL_REGISTRY}/openfaas${image_path}"
  docker tag "${original_image}" "${target_image}"
  docker push "${target_image}"
done < container_images/required_images.txt

2. Inicialización del Repositorio Helm Local

Configuramos un repositorio de Helm basado en el sistema de archivos local para que el clúster pueda consumir el chart sin acceder a internet.

LOCAL_REPO_PATH="/opt/local-helm-charts"
mkdir -p "${LOCAL_REPO_PATH}"
cp helm_charts/*.tgz "${LOCAL_REPO_PATH}/"

helm repo index "${LOCAL_REPO_PATH}"
helm repo add airgap-faas "file://${LOCAL_REPO_PATH}"

Ejecución del Despliegue Offline

1. Script de Instalación Automatizada

Creamos un script de bash que gestiona la creación de secretos, la aplicación de namespaces y la instalación mediante Helm. Se utiliza un archivo values.yaml temporal para mantener el comando de Helm limpio y manejable.

#!/usr/bin/env bash
set -euo pipefail

echo "Iniciando despliegue de OpenFaaS en modo aislado..."

# Aplicar namespaces
kubectl apply -f ./base_yamls/namespaces.yml

# Generar credenciales de acceso
ADMIN_USER="admin"
ADMIN_PASS=$(openssl rand -hex 16)

kubectl create secret generic basic-auth \
  --namespace openfaas \
  --from-literal=basic-auth-user="${ADMIN_USER}" \
  --from-literal=basic-auth-password="${ADMIN_PASS}" \
  --dry-run=client -o yaml | kubectl apply -f -

# Generar archivo de valores personalizados
cat <<eof> custom_values.yaml
basic_auth: true
functionNamespace: openfaas-fn
serviceType: ClusterIP
gateway:
  image: registry.internal.corp:5000/openfaas/gateway:0.26.3
queueWorker:
  image: registry.internal.corp:5000/openfaas/queue-worker:0.13.0
EOF

# Desplegar con Helm
helm upgrade --install openfaas airgap-faas/openfaas \
  --namespace openfaas \
  --values custom_values.yaml \
  --wait --timeout 5m0s

echo "Despliegue finalizado. Credenciales -> Usuario: ${ADMIN_USER}, Contraseña: ${ADMIN_PASS}"</eof>

2. Ejecución y Validación

Otorgamos permisos de ejecución al script y lo lanzamos. Posteriormente, verificamos el estado de los pods y la accesibilidad del gateway.

chmod +x deploy_offline_faas.sh
./deploy_offline_faas.sh

# Verificar estado de los componentes
kubectl get pods -n openfaas -l app=openfaas

# Comprobar endpoints del servicio (asumiendo port-forward para pruebas locales)
kubectl port-forward -n openfaas svc/gateway 8080:8080 &

# Validar la API del sistema
curl -s -u "admin:${ADMIN_PASS}" http://127.0.0.1:8080/system/functions | jq .

Consideraciones Técnicas para Producción

• Sincronización de Registros: Asegúrese de que todas las referencias de imágenes en el archivo values.yaml apunten estrictamente al registro interno. Cualquier imagen que intente descargarse desde Docker Hub o GHCR provocará un estado ImagePullBackOff.
• Persistencia de Datos: Para componentes como NATS Streaming o el almacenamiento de secretos, habilite los volúmenes persistentes (PVC) añadiendo persistence.enabled=true en la configuración de Helm.
• Cifrado en Tránsito: En redes aisladas, es igualmente crítico configurar Ingress con certificados TLS (por ejemplo, usando cert-manager con un CA interno) para protegre las credenciales y el tráfico de las funciones.
• Topología de Red: Si no dispone de un balanceador de carga metálico (MetalLB), cambie el tipo de servicio a NodePort o utilice un Ingress Controller para exponer el gateway.

Matriz de Compatibilidad de Componentes Base