[{"content":"","date":null,"permalink":"https://mamux.org/es/","section":"mamux.org","summary":"","title":"mamux.org"},{"content":"","date":null,"permalink":"https://mamux.org/es/posts/","section":"Posts","summary":"","title":"Posts"},{"content":"Esta guía documenta cómo reemplazar el ONT Livebox 6s (ZTE ZXHN F6640P) proporcionado por Pepephone (grupo MasMovil, operando sobre la infraestructura GPON de Orange España) con un stick SFP Huawei G-010S-P con firmware comunitario. Esto te permite usar tu propio router directamente con un puerto SFP, eliminando completamente el router del ISP.\n¿Por qué reemplazar el ONT? # El Livebox 6s es un router + ONT combinado. Si quieres usar tu propio router (por ejemplo, MikroTik, pfSense, OPNsense), necesitas poner el Livebox en modo bridge o reemplazar su función ONT completamente con un stick SFP. El enfoque de stick SFP es más limpio: tu router maneja todo, y no necesitas el Livebox encendido.\nRequisitos previos # Un stick SFP Huawei G-010S-P con firmware comunitario (chipset Lantiq Falcon, basado en OpenWrt). La unidad específica usada en esta guía fue comprada en AliExpress (Color: MA5671A). Acceso SSH/serial al stick SFP (la IP predeterminada suele ser 192.168.1.10) Un router o convertidor de medios con un puerto SFP Acceso a la interfaz de administración del Livebox 6s (generalmente en 192.168.1.1) para recopilar los valores de identidad Paso 1: Recopilar valores de identidad del Livebox 6s # El OLT (equipo de Orange en la oficina central) autentica los ONT verificando múltiples campos de identidad. Necesitas clonar todos ellos desde el Livebox 6s original al stick SFP.\nNavega a la página de estado/información de la interfaz de administración del Livebox 6s. Necesitas:\nCampo en la UI del Livebox Valor de ejemplo Usado para Número de serie (GPON SN) ZTEGXXXXXXXX Número de serie GPON Contraseña de ONT XXXXXXXXXX Contraseña PLOAM Modelo ZTEGFIBRA6S ID de equipo OMCI Versión de hardware ZTEGLBFIB6S1.0.0 Versión de software OMCI Versión del bootloader V11.0.10P10N10 Versión de software OMCI Paso 2: Configurar el stick SFP # Conéctate por SSH al stick SFP y ejecuta los siguientes comandos.\nEstablecer la identidad GPON (UCI) # # Número de serie GPON uci set gpon.onu.nSerial=ZTEGXXXXXXXX # Contraseña PLOAM (texto plano) uci set gpon.onu.ploam_password=XXXXXXXXXX Establecer los campos de identidad OMCI (UCI) # Estos campos se reportan al OLT durante la fase de configuración OMCI. Si no coinciden con lo que el OLT espera para el número de serie registrado, el OLT enviará un mensaje DACT (Desactivar) y expulsará la ONU de la red.\nuci set gpon.onu.vendor_id=ZTEG uci set gpon.onu.equipment_id=ZTEGFIBRA6S uci set gpon.onu.ont_version=ZTEGLBFIB6S1.0 uci set gpon.onu.mib_customized=1 uci delete gpon.onu.mib_file uci commit gpon Notas importantes:\nont_version es la versión de hardware. El campo OMCI tiene un límite de 14 bytes, por lo que ZTEGLBFIB6S1.0.0 (17 caracteres) se trunca a ZTEGLBFIB6S1.0. mib_customized=1 habilita el generador de MIB personalizado que aplica el vendor_id, equipment_id y ont_version a las entidades gestionadas OMCI. uci delete gpon.onu.mib_file es crítico — sin esto, el script de inicio usa el archivo MIB configurado previamente (data_1g_8q_us1280_ds512.ini) y omite por completo la generación de MIB personalizado, ignorando tu configuración de identidad. Establecer la versión de software (entorno u-boot) # El OLT verifica la versión de software reportada vía OMCI Entidad Gestionada 7 (Imagen de Software). Este valor proviene de la variable u-boot image0_version y debe coincidir con la versión del bootloader del Livebox. Este es el único campo que requiere fw_setenv — no tiene equivalente UCI.\nfw_setenv image0_version V11.0.10P10N10 Reiniciar # reboot Paso 3: Verificar la configuración # Después del reinicio, vuelve a conectarte por SSH y verifica que todo esté correcto.\nVerificar el estado PLOAM # onu ploamsg Un registro exitoso muestra curr_state=5 (Operacional / O5). Si ves esto, el stick SFP está autenticado y conectado.\nVerificar la identidad OMCI (ONU-G — ME 256) # omci_pipe.sh meg 256 0 Esperado: ID de proveedor = ZTEG, Versión = ZTEGLBFIB6S1.0\nVerificar el ID de equipo OMCI (ONU2-G — ME 257) # omci_pipe.sh meg 257 0 Esperado: ID de equipo = ZTEGFIBRA6S\nVerificar la versión de software (Imagen de Software — ME 7) # omci_pipe.sh meg 7 0 Esperado: Versión = V11.0.10P10N10\nSolución de problemas # El bucle DACT # El modo de fallo más común es un bucle de desactivación PLOAM. Los síntomas se ven así al monitorear con onu ploamsg:\ncurr_state=3 previous_state=2 # Fase de descubrimiento, onu_id=255 curr_state=4 previous_state=3 # Intercambio de contraseña/configuración OMCI, onu_id asignado curr_state=2 previous_state=5 # ¡DACT recibido! De vuelta al ranging curr_state=3 previous_state=2 # Redescubrimiento... ciclo se repite cada ~30s Esto significa que el OLT reconoce el número de serie, asigna un ID de ONU, inicia la configuración OMCI y luego rechaza la ONU.\nReferencia de estados PLOAM # En el firmware del G-010S-P, los estados PLOAM se mapean de la siguiente manera:\nEstado Estado GPON Significado 2 O4 — Ranging La ONU está siendo rangada por el OLT 3 O3 — Número de serie La ONU está en descubrimiento, esperando concesión de número de serie 4 O6 — Popup Intercambio de contraseña / inicio de configuración OMCI 5 O5 — Operación Totalmente registrada y operativa Comandos de diagnóstico # Comando Qué muestra onu ploamsg Estado actual de la máquina de estados PLOAM onu gtcsg Estado GTC: onu_id, FEC, estado de downstream onu gtcag Alarmas GTC: ploam_dact, loss_of_allocation, etc. onu gtccg Configuración GTC: contraseña PLOAM, timeouts onu gtcsng Número de serie GPON omci_pipe.sh meg 256 0 OMCI ONU-G: vendor_id, versión de hardware omci_pipe.sh meg 257 0 OMCI ONU2-G: equipment_id omci_pipe.sh meg 7 0 OMCI Imagen de Software: versión del firmware fw_printenv Todas las variables de entorno u-boot uci show gpon Configuración GPON UCI Causas comunes de DACT # vendor_id OMCI incorrecto: Los archivos MIB predeterminados en el G-010S-P establecen vendor_id a SPGA o HWTC. Debe ser ZTEG para el F6640P.\nequipment_id incorrecto: El valor predeterminado es SPGMAC o MA5671A. Debe coincidir con el identificador del modelo del Livebox (ZTEGFIBRA6S).\nVersión de hardware incorrecta (ont_version): El valor predeterminado es CC4.A. Debe coincidir con la versión de hardware del Livebox.\nVersión de software incorrecta: La variable u-boot image0_version tiene como valor predeterminado la versión del firmware propio del stick SFP (6BA1896SPE2C05). Debe coincidir con la versión del bootloader del Livebox.\nTrampa de prioridad del archivo MIB: Incluso con mib_customized=1, el script de inicio verifica si existe una configuración UCI gpon.onu.mib_file antes de verificar la bandera mib_customized. Si mib_file está configurado con una ruta a un archivo .ini no personalizado, la generación de MIB personalizado se omite por completo. Solución: uci delete gpon.onu.mib_file.\nIncompatibilidad de contraseña PLOAM: Verifica que la contraseña en la interfaz de administración del Livebox coincida con la configurada en el stick SFP.\nVerificar los contadores de alarmas GTC # Ejecuta onu gtcag y busca estos campos clave:\nploam_dact=1 — El OLT envió un mensaje de Desactivación. Esto confirma el rechazo activo (no es un problema de señal/timing). ploam_dis=1 — El OLT envió un mensaje de Deshabilitación. Diferente de DACT; generalmente significa que la ONU está deshabilitada administrativamente en el lado del OLT. loss_of_allocation=256 — El parpadeo on/off es normal durante la fase de descubrimiento cuando no se asigna un mapa de ancho de banda. ploam_mis=1 — Incompatibilidad PLOAM. Podría indicar problemas con el número de serie. Problemas de señal óptica # Si la ONU nunca alcanza el estado 3 (se queda en el estado 1 o 2 sin progresar), el problema es probablemente físico:\nVerificar la conexión de fibra Verificar que la potencia Rx esté dentro del rango (-8 a -28 dBm) Asegurarse de que el stick SFP esté correctamente insertado en el puerto SFP Verificar que el Livebox original esté desconectado físicamente de la fibra — dos dispositivos con el mismo número de serie en el mismo árbol PON causarán conflictos Referencia completa de comandos # Aquí está la configuración completa en un solo bloque para facilitar el copiar y pegar (reemplaza los valores con los tuyos):\n# Identidad GPON uci set gpon.onu.nSerial=ZTEGXXXXXXXX uci set gpon.onu.ploam_password=XXXXXXXXXX # Campos de identidad OMCI uci set gpon.onu.vendor_id=ZTEG uci set gpon.onu.equipment_id=ZTEGFIBRA6S uci set gpon.onu.ont_version=ZTEGLBFIB6S1.0 # Habilitar generación de MIB personalizado y borrar cualquier ruta de archivo MIB existente uci set gpon.onu.mib_customized=1 uci delete gpon.onu.mib_file uci commit gpon # Versión de software (requiere fw_setenv, sin equivalente UCI) fw_setenv image0_version V11.0.10P10N10 # Aplicar cambios reboot Después del reinicio, verifica con:\n# Debería mostrar curr_state=5 (operacional) onu ploamsg # Debería mostrar ZTEG / ZTEGLBFIB6S1.0 omci_pipe.sh meg 256 0 # Debería mostrar ZTEGFIBRA6S omci_pipe.sh meg 257 0 # Debería mostrar V11.0.10P10N10 omci_pipe.sh meg 7 0 ","date":"20 de enero de 2026","permalink":"https://mamux.org/es/posts/gpon-sfp-setup/","section":"Posts","summary":"","title":"Stick SFP Huawei G-010S-P en Pepephone"},{"content":"Un viaje desde la administración de un solo servidor hasta una gestión integral multi-servidor de FDO\nIntroducción # FIDO Device Onboard (FDO) está revolucionando la forma en que conectamos de manera segura dispositivos IoT a escala. Sin embargo, a medida que los despliegues de FDO crecen, las organizaciones suelen encontrarse gestionando múltiples servidores FDO con diferentes roles: Fabricantes que crean vouchers de propiedad, Servidores de Rendezvous que facilitan el descubrimiento de dispositivos, y Owners que gestionan certificados y configuraciones de dispositivos.\nNos propimos construir una interfaz web que pudiera simplificar esta complejidad, facilitando la gestión de múltiples servidores FDO desde una única interfaz. Esta es la historia de cómo transformamos una herramienta básica de administración de un solo servidor en una plataforma integral de gestión multi-servidor.\nEl desafío: Gestionar múltiples servidores FDO # En despliegues reales de FDO, normalmente tienes tres roles de servidor distintos:\nServidores Fabricante: Generan y gestionan vouchers de propiedad para dispositivos durante su fabricación Servidores Rendezvous: Facilitan la conexión inicial entre dispositivos y sus propietarios durante el proceso de onboarding Servidores Owner: Gestionan certificados de dispositivos, vouchers de propiedad y configuraciones finales de dispositivos Antes de esta interfaz, los administradores tenían que:\nLlevar un registro manual de múltiples URLs de servidores Cambiar entre diferentes pestañas del navegador o herramientas para cada servidor Recordar qué APIs proporciona cada rol de servidor Probar manualmente las conexiones para verificar la salud del servidor Sabíamos que debía haber una mejor manera.\nLa visión: Una interfaz, muchos servidores # Nuestro objetivo era simple: crear una única interfaz donde puedas gestionar todos tus servidores FDO, independientemente de su rol o ubicación.\nLos requisitos clave incluían:\nSoporte para los tres roles de servidor FDO Cambio fácil de servidor con un solo clic Navegación basada en roles mostrando solo las APIs relevantes Monitoreo de salud de la conexión Funciona de forma independiente o como plugin del OpenShift Console Compatible con versiones anteriores con despliegues de un solo servidor El viaje: De simple a sofisticado # Fase 1: Entender el panorama # Comenzamos con una interfaz básica de un solo servidor que podía:\nMostrar vouchers de propiedad Subir certificados CA de dispositivos Mostrar información de rendezvous Funcionaba bien para despliegues simples, pero los usuarios con múltiples servidores se encontraban manejando múltiples ventanas del navegador y perdiendo la pista de qué servidor estaban viendo.\nFase 2: Introducir contexto del servidor # El avance llegó cuando implementamos un sistema de contexto del servidor. Esto permite que toda la interfaz \u0026ldquo;sepa\u0026rdquo; con qué servidor estás trabajando actualmente y configure automáticamente todas las llamadas API para usar ese servidor.\nLa pieza central es un selector de servidores en la cabecera de la aplicación. Con un solo clic, puedes:\nVer todos tus servidores configurados de un vistazo Cambiar entre servidores al instante Ver el rol y estado de conexión de cada servidor Ir a la gestión del servidor Fase 3: Navegación inteligente basada en roles # Diferentes roles de servidor FDO proporcionan diferentes APIs. Un servidor Fabricante tiene APIs de vouchers e información de rendezvous, pero no tiene la API de CA de dispositivos. Un servidor Owner tiene todo excepto información de rendezvous.\nImplementamos una navegación inteligente que muestra solo los elementos del menú relevantes para el rol del servidor seleccionado:\nFabricante: Salud, Vouchers, Información de Rendezvous Owner: Salud, Vouchers, CAs de Dispositivos, Direcciones RV TO2 Rendezvous: Salud, CAs de Dispositivos Ya no hay confusión sobre qué APIs están disponibles en cada servidor: la interfaz te lo indica automáticamente.\nLa navegación se adapta según el rol del servidor - aquí mostrando el rol Fabricante con Vouchers e Información de Rendezvous\nMisma interfaz con el rol Owner seleccionado - ahora mostrando CAs de Dispositivos y Direcciones RV TO2\nFase 4: Gestión de servidores simplificada # Construimos una interfaz integral de gestión de servidores donde puedes:\nAgregar Nuevos Servidores: Simplemente proporciona un nombre, URL y rol. La interfaz prueba la conexión automáticamente antes de guardar.\nVer Todos los Servidores de un Vistazo: Una tabla que muestra todos tus servidores con:\nNombre y URL del servidor Rol (con insignias de colores) Estado de conexión (saludable/no saludable) Acciones rápidas (editar, probar conexión, eliminar) Probar Conexiones: Verificaciones de salud con un solo clic que confirman que tus servidores están respondiendo correctamente.\nFase 5: Resolver el problema de cambio de contexto # Las pruebas iniciales revelaron un problema sutil pero crítico: cuando los usuarios cambiaban de servidor e intentaban subir certificados, ¡los archivos seguían yendo al servidor original!\nEste fue nuestro momento \u0026ldquo;ajá\u0026rdquo;. Nos dimos cuenta de que cada parte de la interfaz debía respetar el contexto del servidor: no solo las operaciones de lectura, sino también las subidas, ediciones y eliminaciones.\nActualizamos sistemáticamente cada componente que se comunicaba con los servidores FDO para usar el contexto del servidor actual. Ahora, todo: desde ver vouchers hasta subir certificados - siempre usa el servidor que has seleccionado.\nFase 6: Flexibilidad de despliegue # Diseñamos la interfaz para funcionar en dos modos de despliegue:\nModo Independiente: Usa el almacenamiento local del navegador para guardar las configuraciones de tus servidores. Perfecto para desarrollo o cuando se ejecuta fuera de OpenShift.\nModo Plugin del OpenShift Console: Lee las configuraciones de servidores desde Definiciones de Recursos Personalizados (CRDs) de Kubernetes. Los administradores pueden gestionar servidores mediante kubectl o el OpenShift Console, y la interfaz los descubre automáticamente.\nEsta flexibilidad significa que la interfaz funciona para todos: desde desarrolladores probando localmente hasta despliegues de producción en OpenShift.\nCaracterísticas principales # Gestión Multi-Servidor # Agregar, editar y eliminar servidores con una interfaz intuitiva Selector de servidores en la cabecera de la aplicación para cambio instantáneo Selección persistente del servidor: la interfaz recuerda con qué servidor estás trabajando Monitoreo de salud de conexión con indicadores de estado en tiempo real Interfaz Basada en Roles # Descubrimiento automático de APIs: la interfaz se adapta al rol de cada servidor Insignias de colores para roles (Fabricante: Azul, Owner: Verde, Rendezvous: Púrpura) Navegación dinámica mostrando solo las APIs disponibles Operaciones conscientes del rol: subir vouchers solo a servidores que lo soporten Gestión de Vouchers de Propiedad # Listar todos los vouchers con GUID, versión del protocolo e información de rendezvous Ver detalles del voucher incluyendo información del dispositivo Subir nuevos vouchers con soporte multi-archivo Actualizar vouchers existentes reemplazando el archivo PEM Eliminar vouchers con diálogos de confirmación Gestión de Certificados CA de Dispositivos # Ver todos los certificados CA de dispositivos con fechas de expiración e huellas digitales Subir certificados en lote (formatos PEM, CRT, CER) Eliminar certificados de forma segura con advertencias de impacto Detalles del certificado mostrando información completa del certificado Gestión de Información de Rendezvous # Configurar endpoints de rendezvous para descubrimiento de dispositivos Gestionar múltiples entradas RV por servidor Editar y eliminar configuraciones de rendezvous Gestión de Direcciones RV TO2 # Configurar direcciones TO2 (Transfer Ownership 2) para entrega de dispositivos Gestionar protocolos de transporte y configuraciones de endpoints Editar y actualizar configuraciones TO2 a medida que evolucionan los despliegues Mejoras de Experiencia de Usuario # Manejo de errores en tiempo real con notificaciones toast Alertas de conexión cuando los servidores se vuelven no disponibles Estados de carga con skeleton loaders de PatternFly Diálogos de confirmación previniendo eliminaciones accidentales Subida multi-archivo con seguimiento de progreso Estados vacíos guiando a los usuarios cuando no hay datos El stack tecnológico # Construimos esta interfaz usando tecnologías web modernas optimizadas para aplicaciones empresariales:\nReact 18 para una arquitectura responsiva basada en componentes TypeScript para seguridad de tipos y mejor experiencia de desarrollo PatternFly 6 para componentes de interfaz empresarial y accesibilidad Generación de código OpenAPI para clientes API con seguridad de tipos Servidor Mock Express.js para desarrollo local y pruebas El sistema de diseño PatternFly fue crucial: proporcionó\nAccesibilidad (cumplimiento WCAG 2.1 AA) de forma predeterminada Patrones UX consistentes familiares para usuarios de OpenShift Componentes de calidad empresarial (tablas, modales, formularios, alertas) Diseño responsivo que funciona en cualquier tamaño de pantalla Impacto en el mundo real # Esta interfaz resuelve problemas reales para administradores de FDO:\nAntes: \u0026ldquo;Tengo tres servidores FDO para pruebas, staging y producción. Llevo un archivo de texto con URLs y tengo tres ventanas del navegador abiertas. Cuando subo vouchers, a veces olvido qué pestaña es cuál y subo al entorno equivocado.\u0026rdquo;\nDespués: \u0026ldquo;Ahora tengo los tres servidores configurados en la interfaz. El selector de servidores me muestra exactamente con cuál estoy trabajando. La insignia del fabricante es azul, así que sé al instante que estoy en el servidor de pruebas. Subo vouchers con confianza sabiendo que van al lugar correcto.\u0026rdquo;\nAntes: \u0026ldquo;Nuestro servidor de rendezvous no tiene la API de vouchers, pero nuestra interfaz antigua mostraba el menú de vouchers de todas formas. Al hacer clic solo daba errores. Muy confuso.\u0026rdquo;\nDespués: \u0026ldquo;Cuando seleccionamos nuestro servidor de rendezvous, la interfaz solo muestra Salud y CAs de Dispositivos: exactamente lo que ese servidor soporta. La interfaz te guía a lo que realmente puedes hacer.\u0026rdquo;\nAntes: \u0026ldquo;Ejecutamos en OpenShift y nuestro equipo de seguridad gestiona servidores FDO como CRDs. Tenía que pedirles las URLs cada vez que algo cambiaba.\u0026rdquo;\nDespués: \u0026ldquo;La interfaz descubre automáticamente todos los servidores FDO en nuestro namespace. Cuando el equipo agrega un nuevo servidor, simplemente aparece en mi lista de servidores. No se necesita configuración.\u0026rdquo;\nServidor Mock de Desarrollo # Para facilitar el desarrollo local, creamos un servidor FDO mock completo:\nTodas las APIs FDO implementadas con respuestas realistas Persistencia basada en archivos: los datos sobreviven reinicios del servidor Instancias aisladas: cada servidor mock obtiene su propio directorio de datos Simulación multi-servidor: ejecutar múltiples mocks en diferentes puertos Datos de ejemplo precargados para pruebas inmediatas Los desarrolladores pueden comenzar a codificar inmediatamente con:\nnpm run start:dev:mock Esto inicia tanto el servidor mock FDO como el servidor de desarrollo de la interfaz, listo para usar.\nLecciones aprendidas # 1. El contexto lo es todo # Construir una aplicación verdaderamente consciente del contexto significa que cada interacción debe respetar el contexto actual. Perder incluso una operación (como hicimos inicialmente con las subidas) rompe la experiencia del usuario.\n2. Diseñar para la flexibilidad # Soportar múltiples modos de despliegue (independiente y plugin de OpenShift) desde el primer día hizo la arquitectura más robusta. El patrón del adaptador de almacenamiento hizo esto transparente.\n3. Las interfaces basadas en roles son poderosas # Mostrar a los usuarios solo lo relevante para su contexto actual (rol del servidor) reduce la carga cognitiva y previene errores. La navegación dinámica basada en las capacidades del servidor fue un cambio radical.\n4. Probar con flujos de trabajo reales # El error de subir al servidor equivocado solo apareció al probar flujos de trabajo realistas: cambiar de servidor y luego subir inmediatamente. Las pruebas automáticas capturaron errores de compilación, pero las pruebas con usuarios capturaron problemas de UX.\n5. La experiencia del desarrollador importa # El servidor mock transformó el desarrollo. Los ingenieros pueden probar escenarios multi-servidor localmente sin desplegar servidores FDO reales. Esto aceleró significativamente el desarrollo.\nPróximos pasos # Estamos continuando mejorando la interfaz basándonos en los comentarios de los usuarios:\nOperaciones por lote: Seleccionar múltiples vouchers o certificados para acciones en lote Advertencias de expiración de certificados: Alertas proactivas para CAs de dispositivos por expirar Búsqueda y filtrado: Filtrado avanzado en todos los tipos de recursos Funcionalidad de exportación: Descargar vouchers y certificados en varios formatos Visualización de cadena de certificados: Entender las relaciones CA de un vistazo Registro de auditoría: Rastrear quién hizo qué cambios y cuándo Integración RBAC: Permisos finos para despliegues en OpenShift Conclusión # Lo que comenzó como una interfaz simple de un solo servidor evolucionó en una sofisticada plataforma de gestión multi-servidor. Al centrarnos en las necesidades reales de los usuarios: gestionar múltiples servidores FDO con diferentes roles, creamos una herramienta que hace la administración de FDO más rápida, segura e intuitiva.\nEl viaje nos enseñó que las grandes interfaces no se tratan solo de funciones: se trata de entender los flujos de trabajo del usuario y eliminar la fricción. Ya sea que gestiones dos o veinte servidores FDO, cambiar entre ellos debería ser sin esfuerzo. Ya seas un fabricante subiendo vouchers o un owner gestionando certificados de dispositivos, la interfaz debería guiarte hacia el éxito.\nEstamos emocionados por ver cómo la comunidad FDO utiliza esta interfaz para optimizar sus flujos de trabajo de onboarding de dispositivos. Si estás trabajando con FIDO Device Onboard, nos encantaría saber sobre tu experiencia y casos de uso.\nPruébalo tú mismo # La interfaz es de código abierto y está lista para usar:\nClonar el repositorio: git clone https://github.com/mmartinv/go-fdo-server-ui-prototype Instalar dependencias: npm install Iniciar el servidor mock y la interfaz: npm run start:dev:mock Abrir tu navegador: Navega a http://localhost:9000 Agrega tu primer servidor, explora la interfaz y descubre cómo la gestión multi-servidor de FDO puede ser simple e intuitiva.\n¿Preguntas, comentarios o quieres contribuir? Abrir un issue o pull request en GitHub\nSobre FIDO Device Onboard (FDO) # FIDO Device Onboard es un protocolo de onboarding automático para dispositivos IoT desarrollado por la FIDO Alliance. Permite que los dispositivos se conecten de manera segura a sus plataformas de gestión sin credenciales preconfiguradas, resolviendo el \u0026ldquo;problema del desempaquetado\u0026rdquo; para IoT a escala. Aprende más en fidoalliance.org.\n","date":"8 de enero de 2025","permalink":"https://mamux.org/es/posts/go-fdo-server-ui/","section":"Posts","summary":"","title":"Construyendo una interfaz de gestión multi-servidor para FIDO Device Onboard (FDO)"},{"content":"La nueva versión 0.5.0 de fdo-device-onboard-rs viene con soporte preliminar de base de datos como Vista Tecnológica. Sin embargo, algunas de las versiones posteriores no funcionan correctamente ya que les faltan algunas políticas SELinux necesarias:\n(allow fdo_t etc_t (file (write))) (allow fdo_t fdo_conf_t (file (append create rename setattr unlink write))) (allow fdo_t fdo_var_lib_t (dir (add_name remove_name write))) (allow fdo_t fdo_var_lib_t (file (create setattr unlink write))) (allow fdo_t krb5_keytab_t (dir (search))) (allow fdo_t postgresql_port_t (tcp_socket (name_connect))) (allow fdo_t sssd_t (unix_stream_socket (connectto))) (allow fdo_t sssd_var_run_t (sock_file (write))) Para instalarlas simplemente guarde el contenido anterior como local-fdo-db.cil y ejecute los siguientes comandos:\n[root@localhost:~]# dnf install -y policycoreutils [root@localhost:~]# semodule -i local-fdo-db.cil ","date":"20 de enero de 2024","permalink":"https://mamux.org/es/posts/fido-db-selinux-policies/","section":"Posts","summary":"","title":"El soporte de base de datos de FIDO Device Onboard falta con algunas políticas SELinux"},{"content":"Forklift proporciona una forma sencilla para la migración a gran escala de máquinas virtuales (VMs) a Kubernetes desde hipervisores tradicionales como VMware (vSphere) y Red Hat Virtualization (oVirt) hacia KubeVirt.\nLa nueva versión (v2.5.0) soportará dos métodos de autenticación adicionales aparte del habitual usuario y contraseña:\nAutenticación por token Autenticación con credenciales de aplicación Por completitud, describiremos cómo configurar todos los tipos de autenticación disponibles.\nPrerequisitos # La mayor parte de la información requerida para la configuración se puede obtener desde el panel de OpenStack haciendo clic en tu nombre de usuario en la esquina superior derecha y descargando el Openstack RC File.\nDeberías obtener un archivo con algo similar a lo siguiente:\nexport OS_AUTH_URL=http://192.168.100.181:5000 export OS_PROJECT_ID=dbed38bf449b495295868afa61a565dc export OS_PROJECT_NAME=\u0026#34;forklift\u0026#34; export OS_USER_DOMAIN_NAME=\u0026#34;Default\u0026#34; if [ -z \u0026#34;$OS_USER_DOMAIN_NAME\u0026#34; ]; then unset OS_USER_DOMAIN_NAME; fi export OS_PROJECT_DOMAIN_ID=\u0026#34;default\u0026#34; if [ -z \u0026#34;$OS_PROJECT_DOMAIN_ID\u0026#34; ]; then unset OS_PROJECT_DOMAIN_ID; fi unset OS_TENANT_ID unset OS_TENANT_NAME export OS_USERNAME=\u0026#34;forklift\u0026#34; echo \u0026#34;Please enter your OpenStack Password for project $OS_PROJECT_NAME as user $OS_USERNAME: \u0026#34; read -sr OS_PASSWORD_INPUT export OS_PASSWORD=$OS_PASSWORD_INPUT export OS_REGION_NAME=\u0026#34;RegionOne\u0026#34; if [ -z \u0026#34;$OS_REGION_NAME\u0026#34; ]; then unset OS_REGION_NAME; fi export OS_INTERFACE=public export OS_IDENTITY_API_VERSION=3 Autenticación con usuario/contraseña # Campos requeridos:\nauthType=password username=forklift password=redhat regionName=RegionOne projectName=forklift domainName=Default Crear el secreto desde la línea de comandos:\nkubectl -n konveyor-forklift create secret generic openstack-password-authentication --from-env-file=openstack-password-authentication Definición del proveedor:\napiVersion: forklift.konveyor.io/v1beta1 kind: Provider metadata: name: provider-with-password-authentication namespace: konveyor-forklift spec: secret: name: openstack-password-authentication namespace: konveyor-forklift type: openstack url: http://192.168.100.181:5000 Crear el proveedor desde la línea de comandos:\nkubectl apply -f provider-with-password-authentication.yaml Autenticación por token # Generar el token en el lado de OpenStack:\nopenstack --os-cloud=forklift token issue +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Field | Value | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | expires | 2023-05-11T11:14:11+0000 | | id | gAAAAABkXL_zpOrVRMG-_LVlaVzdablXr9JrMo_-mbJqG_inu-aK848irCL9yZXoiQ4Olq4l_vkwNOZWfoFKxgYPtzJJsIYFx3GwrzOLD3vavNR8ENXR7ynrKllEAj9Tsy_AgjQIR43gg91IcUSBcOtm4cGbpjWRH-9JNJuCYefxDMNW0kDNkJ4 | | project_id | dbed38bf449b495295868afa61a565dc | | user_id | abd6e32701a944d1b52727ff58e0fb3e | +------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ Ahora podemos usar los campos token, project_id y user_id devueltos para la autenticación:\nauthType=token token=gAAAAABkXL_zpOrVRMG-_LVlaVzdablXr9JrMo_-mbJqG_inu-aK848irCL9yZXoiQ4Olq4l_vkwNOZWfoFKxgYPtzJJsIYFx3GwrzOLD3vavNR8ENXR7ynrKllEAj9Tsy_AgjQIR43gg91IcUSBcOtm4cGbpjWRH-9JNJuCYefxDMNW0kDNkJ4 userID=abd6e32701a944d1b52727ff58e0fb3e projectID=dbed38bf449b495295868afa61a565dc También es posible usar el nombre de usuario y el nombre del proyecto. Sin embargo, usar el nombre del proyecto también requiere especificar la variable domainName:\nauthType=token token=gAAAAABkXL_zpOrVRMG-_LVlaVzdablXr9JrMo_-mbJqG_inu-aK848irCL9yZXoiQ4Olq4l_vkwNOZWfoFKxgYPtzJJsIYFx3GwrzOLD3vavNR8ENXR7ynrKllEAj9Tsy_AgjQIR43gg91IcUSBcOtm4cGbpjWRH-9JNJuCYefxDMNW0kDNkJ4 username=forklift projectName=forklift domainName=Default Crear el secreto desde la línea de comandos:\nkubectl -n konveyor-forklift create secret generic openstack-token-authentication --from-env-file=openstack-token-authentication Definición del proveedor:\napiVersion: forklift.konveyor.io/v1beta1 kind: Provider metadata: name: provider-with-token-authentication namespace: konveyor-forklift spec: secret: name: openstack-token-authentication namespace: konveyor-forklift type: openstack url: http://192.168.100.181:5000 Crear el proveedor desde la línea de comandos:\nkubectl apply -f provider-with-token-authentication.yaml Autenticación con credenciales de aplicación # Las credenciales de aplicación deben tener un rol asignado que permita leer la información requerida (VMs, Flavors, Imágenes, Volúmenes, Capturas de instantánea, Redes\u0026hellip;) y detener e iniciar VMs (reader y member son los típicos). Las credenciales de autenticación se pueden generar con el siguiente comando:\nopenstack --os-cloud=forklift application credential create \\ --role member --role reader --secret redhat forklift +--------------+----------------------------------+ | Field | Value | +--------------+----------------------------------+ | description | None | | expires_at | None | | id | 9fc3a641041640e1a153e1fd93ef8055 | | name | forklift | | project_id | dbed38bf449b495295868afa61a565dc | | roles | member reader | | secret | redhat | | system | None | | unrestricted | False | | user_id | abd6e32701a944d1b52727ff58e0fb3e | +--------------+----------------------------------+ Ahora podemos usar el id de la aplicación y el secret elegido para la autenticación:\nauthType=applicationcredential applicationCredentialID=9fc3a641041640e1a153e1fd93ef8055 applicationCredentialSecret=redhat También es posible usar el nombre de la credencial de aplicación, pero requiere especificar el username y el domainName:\n# openstack-secret-applicationcredential-auth.env file authType=applicationcredential applicationCredentialName=forklift applicationCredentialSecret=redhat username=forklift domainName=Default Crear el secreto desde la línea de comandos:\nkubectl -n konveyor-forklift create secret generic openstack-secret-applicationcredential-auth --from-env-file=openstack-secret-applicationcredential-auth.env Definición del proveedor:\n# openstack-provider-applicationcredential-auth.yaml file apiVersion: forklift.konveyor.io/v1beta1 kind: Provider metadata: name: openstack-provider-applicationcredential-auth namespace: konveyor-forklift spec: secret: name: openstack-secret-applicationcredential-auth namespace: konveyor-forklift type: openstack url: http://192.168.100.181:5000 Crear el proveedor desde la línea de comandos:\nkubectl apply -f openstack-provider-applicationcredential-auth.yaml ","date":"11 de enero de 2023","permalink":"https://mamux.org/es/posts/forklift-authentication/","section":"Posts","summary":"","title":"Nuevos métodos de autenticación de OpenStack en Forklift"},{"content":"Hace unos meses, Red Hat me prestó una ThinkStation P340 SFF para hacer mi trabajo y después de instalar CentOS 8 Stream tuve un comportamiento extraño: reiniciar el sistema operativo a veces hacía que el sistema se reiniciara indefinidamente. Hacer un apagado forzado y volver a iniciar el sistema parecía solucionar el problema.\nSin embargo, el problema se reproducía a veces en el primer reinicio, a veces en el segundo reinicio, así que conecté un cable DVI al monitor y vi qué estaba pasando, y vi el siguiente error en la secuencia de arranque:\nSystem BootOrder not found. Initializing defaults. Creating boot entry \u0026#34;Boot0000\u0026#34; with label \u0026#34;CentOS Linux\u0026#34; for file \u0026#34;\\EFI\\centos\\shimx64.efi Reset System Para solucionarlo copié cp /boot/efi/EFI/BOOT/BOOTX64.efi /boot/efi/EFI/BOOT/BOOTX64.efi.backup cp -f /boot/efi/EFI/centos/grubx64.efi /boot/efi/EFI/BOOT/BOOTX64.efi reboot Esto parece solucionar el problema, aunque no estoy seguro de la causa raíz\u0026hellip; :(\n","date":"25 de enero de 2022","permalink":"https://mamux.org/es/posts/system-bootorder-not-found-initializing-defaults/","section":"Posts","summary":"","title":"No se encontró el orden de arranque del sistema, inicializando valores predeterminados"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/authentication/","section":"Tags","summary":"","title":"Authentication"},{"content":"La instalación de oVirt cambia la autenticación por defecto del daemon libvirtd en el lado del hipervisor de none a SASL:\n[root@hypervisor-1 ~]# grep auth_unix_rw /etc/libvirt/libvirtd.conf #auth_unix_rw = \u0026#34;none\u0026#34; auth_unix_rw=\u0026#34;sasl\u0026#34; El mecanismo elegido para realizar la autenticación es scram-sha-256:\n[root@hypervisor-1 ~]# cat /etc/sasl2/libvirt.conf ## start vdsm-4.50.0 configuration mech_list: scram-sha-256 sasldb_path: /etc/libvirt/passwd.db Esto hace que virt-manager falle con el siguiente error al intentar conectarse al hipervisor:\nUnable to connect to libvirt qemu+ssh://root@hypervisor-1.example.com/system. authentication failed: Failed to start SASL negotiation: -4 (SASL(-4): no mechanism available: No worthy mechs found) Verify that the \u0026#39;libvirtd\u0026#39; daemon is running on the remote host. Libvirt URI is: qemu+ssh://root@hypervisor-1.example.com/system La razón es que el mecanismo SASL scram-sha-256 no está disponible en el sistema local. En Fedora necesitamos instalar un paquete adicional para proporcionar el mecanismo mencionado:\n[user@client ~]$ sudo dnf install cyrus-sasl-scram Después de instalar el paquete debemos detener virt-manager e iniciarlo de nuevo. Ahora, se nos pedirá el nombre de usuario y contraseña SASL al intentar conectarse al hipervisor oVirt.\nSi no quieres ingresar el nombre de usuario y contraseña cada vez, puedes crear el archivo ~/.config/libvirt/auth.conf con el siguiente contenido.\n[credentials-vdsm] authname=vdsm@ovirt password=shibboleth [auth-libvirt-hypervisor-1.example.com] credentials=vdsm [auth-libvirt-hypervisor-2.example.com] credentials=vdsm [auth-libvirt-hypervisor-3.example.com] credentials=vdsm Para más información consulte la documentación oficial de Autenticación de conexión\n","date":"23 de enero de 2022","permalink":"https://mamux.org/es/posts/connecting-to-ovirt-hypervisor-with-virt-manager/","section":"Posts","summary":"","title":"Conectarse al hipervisor oVirt con virt-manager"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/libvirt/","section":"Tags","summary":"","title":"Libvirt"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/ovirt/","section":"Tags","summary":"","title":"Ovirt"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/","section":"Tags","summary":"","title":"Tags"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/virt-manager/","section":"Tags","summary":"","title":"Virt-Manager"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/certificates/","section":"Tags","summary":"","title":"Certificates"},{"content":"Existen varias formas de establecer una conexión segura HTTP utilizando un certificado de cliente en Java. La forma más sencilla de hacerlo es cambiando el almacén de claves (keystore) por defecto en las variables de entorno correspondientes al iniciar la JVM.\nComo ejemplo, utilizaremos la siguiente Clase que realiza una conexión HTTPS e imprime algunos detalles sobre el certificado del servidor y la respuesta:\nimport java.net.URL; import javax.net.ssl.HttpsURLConnection; import java.net.MalformedURLException; import java.security.cert.Certificate; import java.util.logging.Logger; import java.io.BufferedReader; import java.io.InputStreamReader; import javax.net.ssl.SSLPeerUnverifiedException; import java.io.IOException; public class HTTPSClient { private static String HTTPS_URL = \u0026#34;https://www.google.com\u0026#34;; private final static Logger log = Logger.getLogger( HTTPSClient.class.getName()); public static void main(String[] args) { new HTTPSClient().connect(); } private void connect() { try { URL url = new URL(HTTPS_URL); HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(); conn.connect(); Certificate[] certs = conn.getServerCertificates(); if (conn != null) { for (Certificate cert : certs) { log.info(\u0026#34;Cert Type: \u0026#34; + cert.getType()); log.info(\u0026#34;Cert Hash Code: \u0026#34; + cert.hashCode()); log.info(\u0026#34;Cert Algorithm: \u0026#34; + cert.getPublicKey().getAlgorithm()); log.info(\u0026#34;Cert Format: \u0026#34; + cert.getPublicKey().getFormat()); } } BufferedReader br = new BufferedReader( new InputStreamReader(conn.getInputStream())); String line; while ((line = br.readLine()) != null) { log.info(line); } br.close(); } catch (MalformedURLException e) { e.printStackTrace(); } catch (SSLPeerUnverifiedException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } } A continuación compilaremos el código fuente:\njavac HTTPSClient.java Como se mencionó anteriormente, para realizar una conexión HTTPS con nuestro certificado de cliente necesitaremos cambiar el almacén de claves (keystore) por defecto de la JVM ejecutando el siguiente comando:\njava -Djavax.net.ssl.keyStore=/home/user/certs/user.pfx \\ -Djavax.net.ssl.keyStoreType=PKCS12 \\ -Djavax.net.ssl.keyStorePassword=mypassword \\ HTTPSClient En caso de que el servidor HTTP estuviera configurado con un certificado autofirmado o la CA no esté incluida en el almacén de confianza (truststore) por defecto de la JVM, la conexión fallará con una javax.net.SSLPeerUnverifiedException.\nPara solucionar esto necesitaremos importar el certificado de la CA correspondiente en un nuevo almacén de confianza y decirle a la JVM que lo utilice.\nUtilizaremos el comando keytool incluido con la JVM para importar el certificado de CA del servidor en el almacén de confianza mycacerts:\nkeytool -importcert -file /home/user/certs/myserver.pem \\ -keystore /home/user/certs/mycacerts \\ -storepass changeit -alias myserver Ahora el comando para ejecutar la JVM con el almacén de confianza recién creado sería:\njava -Djavax.net.ssl.keyStore=/home/user/certs/user.pfx \\ -Djavax.net.ssl.keyStoreType=PKCS12 \\ -Djavax.net.ssl.keyStorePassword=mypassword \\ -Djavax.net.ssl.trustStore=/home/user/certs/mycacerts \\ -Djavax.net.ssl.trustStorePassword=changeit \\ -Djavax.net.ssl.trustStoreType=JKS \\ HTTPSClient El enfoque anterior es adecuado para realizar algunas pruebas rápidas, pero puede que necesitemos utilizar diferentes almacenes de confianza o certificados de cliente en distintas partes del código (imagina una aplicación que es cliente de varios servicios HTTPS y se necesitan diferentes certificados de cliente para cada uno).\nA continuación se muestra un ejemplo de código Java que demuestra cómo personalizar el almacén de claves (keystore) y el almacén de confianza (truststore) para un cliente HTTP en particular.\nNo hace falta mencionar que la configuración codificada (hardcoded) debería moverse a un archivo de configuración. Esto se deja como ejercicio para el lector.\nimport java.net.URL; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.TrustManagerFactory; import java.net.MalformedURLException; import java.security.KeyManagementException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.security.UnrecoverableKeyException; import java.security.cert.Certificate; import java.security.cert.CertificateException; import java.util.logging.Logger; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; import java.io.InputStreamReader; import javax.net.ssl.SSLPeerUnverifiedException; import java.io.IOException; public class HTTPSClient { private String HTTPS_URL = \u0026#34;https://www.google.com\u0026#34;; private String KEY_STORE_FILE=\u0026#34;/home/user/certs/user.pfx\u0026#34;; private String KEY_STORE_PASS=\u0026#34;mypassword\u0026#34;; private String TRUST_STORE_FILE=\u0026#34;/home/user/certs/mycacerts\u0026#34;; private String TRUST_STORE_PASS=\u0026#34;changeit\u0026#34;; //Documentado en guías de seguridad (Bajo \u0026#34;Nombres Estándar\u0026#34;) tanto en JVM Oracle 7 /** Valores válidos para JVM Oracle * - SunX509 * Valores válidos para JVM IBM * - IbmX509 */ private String KEY_MANAGER_ALGORITHM = \u0026#34;SunX509\u0026#34;; /** Valores válidos para JVM Oracle * - PKCS12, JKS * Valores válidos para JVM IBM * - PKCS12, JKS, JCEKS */ private String KEY_STORE_FORMAT = \u0026#34;PKCS12\u0026#34;; private String TRUST_STORE_FORMAT = \u0026#34;JKS\u0026#34;; /** Valores válidos para JVM Oracle * - PKIX * Valores válidos para JVM IBM * - PKIX o IbmPKIX o IbmX509 */ private String TRUST_MANAGER_ALGORITHM=\u0026#34;PKIX\u0026#34;; /** Valores válidos para JVM Oracle * - SSL SSLv2 SSLv3 TLS TLSv1 TLSv1.1 TLSv1.2 * Valores válidos para JVM IBM * - SSL SSLv3 TLS_SSL TLS TLSv1 */ // JVM Oracle private String SSL_CONTEXT_ALGORITHM = \u0026#34;TLS\u0026#34;; private final static Logger logger = Logger.getLogger(HTTPSClient.class.getName()); public static void main(String[] args) { new HTTPSClient().connect(); } private void connect() { try { URL url = new URL(HTTPS_URL); HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(); conn.setSSLSocketFactory(getFactory(new File(KEY_STORE_FILE), KEY_STORE_PASS, new File(TRUST_STORE_FILE), TRUST_STORE_PASS)); conn.connect(); Certificate[] certs = conn.getServerCertificates(); if (conn != null) { for (Certificate cert : certs) { logger.info(\u0026#34;Cert Type: \u0026#34; + cert.getType()); logger.info(\u0026#34;Cert Hash Code: \u0026#34; + cert.hashCode()); logger.info(\u0026#34;Cert Algorithm: \u0026#34; + cert.getPublicKey().getAlgorithm()); logger.info(\u0026#34;Cert Format: \u0026#34; + cert.getPublicKey().getFormat()); } } BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream())); String line; while ((line=br.readLine()) != null) { logger.info (line); } br.close(); } catch (MalformedURLException e) { e.printStackTrace(); } catch (SSLPeerUnverifiedException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } private SSLSocketFactory getFactory(File pKeyFile, String pKeyPassword, File pTrustStoreFile, String pTrustStorePassword) { SSLSocketFactory socketFactory = null; try { KeyManagerFactory keyManagerFactory; keyManagerFactory = KeyManagerFactory.getInstance(KEY_MANAGER_ALGORITHM); KeyStore keyStore; keyStore = KeyStore.getInstance(KEY_STORE_FORMAT); InputStream keyInput = new FileInputStream(pKeyFile); keyStore.load(keyInput, pKeyPassword.toCharArray()); keyInput.close(); keyManagerFactory.init(keyStore, pKeyPassword.toCharArray()); TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TRUST_MANAGER_ALGORITHM); KeyStore trustStore; trustStore = KeyStore.getInstance(TRUST_STORE_FORMAT); InputStream trustStoreInput = new FileInputStream(pTrustStoreFile); trustStore.load(trustStoreInput, pTrustStorePassword.toCharArray()); trustStoreInput.close(); trustManagerFactory.init(trustStore); SSLContext context = SSLContext.getInstance(SSL_CONTEXT_ALGORITHM); context.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom()); socketFactory=context.getSocketFactory(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (KeyStoreException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (CertificateException e) { e.printStackTrace(); } catch (UnrecoverableKeyException e) { e.printStackTrace(); } catch (KeyManagementException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return socketFactory; } } ","date":"31 de enero de 2016","permalink":"https://mamux.org/es/posts/java-https-client-certificate/","section":"Posts","summary":"","title":"Cómo usar HTTPS con un certificado de cliente en Java"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/https/","section":"Tags","summary":"","title":"Https"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/java/","section":"Tags","summary":"","title":"Java"},{"content":"Después del nuevo lanzamiento de Zabbix 3.0.0 tuve la necesidad de instalar agentes zabbix actualizados en mis cajas Kurobox, Raspberry Pi y Mac Mini. El problema aquí es que los repositorios oficiales de debian, incluso el experimental, tienen versiones más antiguas y, por otro lado, el repositorio oficial de Zabbix solo está disponible para arquitecturas intel, así que tienes que construirlo desde las fuentes.\nLo primero que necesitas hacer es importar la clave GPG oficial en tu caja debian:\nwget -O - \u0026#34;http://repo.zabbix.com/zabbix-official-repo.key\u0026#34; | apt-key add - Luego agrega el repositorio de fuentes debian oficial a tu lista de fuentes apt en /etc/apt/sources.list.d/zabbix.list :\necho \u0026#34;deb-src http://repo.zabbix.com/zabbix/3.0/debian jessie main\u0026#34; \u0026gt; /etc/apt/sources.list.d/zabbix.list El siguiente paso es instalar las herramientas de desarrollo debian que nos permitirán generar los paquetes debian:\napt-get install build-essential devscripts debhelper Para construir zabbix necesitaremos instalar también las dependencias de construcción:\napt-get build-dep zabbix En este punto, si no tienes java-sdk instalado puedes tener un error indicando que no hay ningún proveedor de \u0026lsquo;java-sdk\u0026rsquo;. Esto se debe a que \u0026lsquo;java-sdk\u0026rsquo; es un paquete virtual proporcionado por varios paquetes reales. Instalar uno de ellos resolverá el problema:\napt-get install default-jdk \u0026amp;\u0026amp; apt-get build-dep zabbix Lo último que necesitamos son las fuentes de zabbix en sí:\nmkdir zabbix; cd zabbix; apt-get source zabbix Ahora tenemos todo lo necesario para construir los paquetes debian oficiales de zabbix.\ncd zabbix-3.0.0; debuild -us -uc Una vez finalizado tendremos los paquetes zabbix en el directorio padre:\ncd .. ; dpkg -i zabbix-agent_3.0.0-1+jessie_powerpc.deb ","date":"6 de enero de 2014","permalink":"https://mamux.org/es/posts/installing-official-zabbix-agentserver-from-deb-sources/","section":"Posts","summary":"\u003cp\u003eDespués del nuevo lanzamiento de Zabbix 3.0.0 tuve la necesidad de instalar\nagentes zabbix actualizados en mis cajas Kurobox, Raspberry Pi y Mac Mini.\nEl problema aquí es que los repositorios oficiales de debian, incluso el\nexperimental, tienen versiones más antiguas y, por otro lado, el\nrepositorio oficial de Zabbix solo está disponible para arquitecturas intel, así que tienes\nque construirlo desde las fuentes.\u003c/p\u003e","title":"Construyendo el Agente/Servidor Zabbix Oficial desde fuentes deb"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/debian/","section":"Tags","summary":"","title":"Debian"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/monitoring/","section":"Tags","summary":"","title":"Monitoring"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/zabbix/","section":"Tags","summary":"","title":"Zabbix"},{"content":"Si has parcheado tu servidor Zabbix 2.2.x para soportar cabeceras HTTP y SSL y quieres actualizar a Zabbix 2.4 oficial sin perder el trabajo previo, debes hacer lo siguiente:\nImportante: Todas las consultas están escritas usando sintaxis de MySQL, por lo que tendrás que adaptarlas si usas otro servidor de base de datos\nDetén el Servidor Zabbix Renombra la columna conflictiva en la base de datos: ALTER TABLE httpstep CHANGE COLUMN headers headers_2_2_x text NOT NULL; Realiza la actualización normal a Zabbix 2.4.0. Una vez que la actualización de la base de datos haya sido completada, detén el Servidor Zabbix nuevamente. Ahora eliminaremos las columnas recién creadas y renombraremos las columnas relacionadas con 2.2.x a los nuevos nombres: ALTER TABLE httptest DROP COLUMN `capath`; ALTER TABLE httptest DROP COLUMN `ssl_cert_file`; ALTER TABLE httptest DROP COLUMN `ssl_key_file`; ALTER TABLE httptest DROP COLUMN `ssl_key_password`; ALTER TABLE httptest DROP COLUMN `verify_peer`; ALTER TABLE httptest DROP COLUMN `verify_host`; ALTER TABLE httpstep DROP COLUMN `headers`; ALTER TABLE httpstep CHANGE COLUMN `headers_2_2_x` `headers` text NOT NULL; ALTER TABLE httptest CHANGE COLUMN `certfile` `ssl_cert_file` varchar(255) DEFAULT \u0026#39;\u0026#39; NOT NULL; ALTER TABLE httptest CHANGE COLUMN `keyfile` `ssl_key_file` varchar(255) DEFAULT \u0026#39;\u0026#39; NOT NULL; ALTER TABLE httptest CHANGE COLUMN `keypass` `ssl_key_password` varchar(64) DEFAULT \u0026#39;\u0026#39; NOT NULL; ALTER TABLE httptest CHANGE COLUMN `verifypeer` `verify_peer` integer(11) DEFAULT \u0026#39;0\u0026#39; NOT NULL; ALTER TABLE httptest CHANGE COLUMN `verifyhost` `verify_host` integer(11) DEFAULT \u0026#39;0\u0026#39; NOT NULL; Asegúrate de haber definido SSLCertLocation SSLKeyLocation y SSCALocation en zabbix_server.conf. Actualiza las configuraciones de tus escenarios web. Ya no se necesitan rutas absolutas ya que los archivos SSL son ahora relativos a las variables SSL{Cert,Key}Location. Inicia tu servidor Zabbix. ¡Disfrútalo!. ","date":"12 de enero de 2014","permalink":"https://mamux.org/es/posts/zabbix-2.4-upgrade-from-patched-2.2.x/","section":"Posts","summary":"","title":"Actualización de Zabbix 2.4 desde 2.2.x parcheado"},{"content":"Actualización6: Zabbix 2.4 ha sido lanzado, aquí los pasos para hacer la actualización sin perder datos.\nActualización5: Parches para las versiones 2.2.5 y 2.2.6\nActualización4: Esta característica ha sido implementada y será lanzada en la próxima versión (2.4). Puedes probar la versión alpha prerelease desde http://www.zabbix.com/rn2.3.1.php. Daré instrucciones para migrar a la nueva versión manteniendo los escenarios web configurados con este parche, ¡estén atentos!\nActualización3: Se corrigió el comportamiento incorrecto. Los encabezados anteriores se mantenían entre pasos http.\nActualización2: Se agregaron parches para la versión 2.2.3 y se añadió soporte de plantillas.\nActualización1: He actualizado ambos parches porque había un evidente memory leak, lo siento pero no soy un programador C experimentado :-(. Gracias a Alexei Vladishev por reportarlo.\nUtilizamos el sistema de monitoreo zabbix en nuestro trabajo y nos encanta. Sin embargo carece de algunas funcionalidades básicas en su implementación de monitoreo web que hace casi inútil esta función para nosotros. Por ejemplo, no puedes modificar los encabezados HTTP como \u0026ldquo;Content-Type\u0026rdquo;, necesario si quieres usar JSON o monitorear servicios web SOAP.\nAlgunas personas están solicitando esta función (ZBXNEXT-282) pero, como puedes ver, no hay planes de implementarla por ahora porque no forma parte del roadmap.\nEste fin de semana intenté implementar esta función porque pensé que no debería ser muy difícil y debo admitir que fue más fácil de lo que esperaba. Me sentí muy cómodo con el código y también agregué algunas funcionalidades adicionales de HTTPS que necesitamos en nuestro trabajo.\nEste parche se aplica a las versiones 2.2.0,2.2.1, 2.2.2, 2.2.3, 2.2.4, 2.2.5, 2.2.6, y proporciona las siguientes características:\nUso de encabezados HTTP personalizados Seleccionar un certificado y clave en conexiones HTTPS salientes y establecer la contraseña de la clave si es necesario. Verificar si el certificado del servidor está firmado por una CA de confianza y/o si el certificado del servidor coincide con el nombre del servidor. Seleccionar un directorio personalizado que contenga nuestras CAs de confianza (debes ejecutar c_rehash dir para que funcione correctamente). Soporte de plantillas. Soporte de macros para todas las nuevas características. Actualización automática de la base de datos si actualizas desde zabbix 2.0. Cambios en la base de datos incluidos en el esquema si lo instalas desde cero. Requisitos. # Necesitarás libcurl compilado con soporte de openssl, en debian:\napt-get build-dep zabbix-server-mysql apt-get install libcurl4-openssl-dev Instrucciones generales # Compilar e instalar el código fuente parcheado\nsvn co svn://svn.zabbix.com/tags/2.2.6 cd 2.2.6 wget http://mamux.org/wp-content/uploads/2014/09/zabbix-web-patch-2.2.6.txt cat zabbix-web-patch-2.2.6.txt | patch -p0 sh bootstrap.sh ./configure --enable-server --with-mysql --with-libcurl ... make dbschema make sudo make install Ahora tienes 3 opciones\nSi estás actualizando zabbix desde la versión 2.0 no tienes que preocuparte porque el servidor zabbix realizará la actualización de la base de datos.\nSi estás instalando desde cero, crea tu base de datos e importa los archivos sql como de costumbre:\ncat database/mysql/{schema,images,data}.sql | mysql -u zabbix -p zabbix Si ya tienes Zabbix 2.2 necesitarás ejecutar la siguiente SQL en tu base de datos zabbix:\nALTER TABLE zabbix.httpstep ADD headers TEXT NOT NULL; ALTER TABLE zabbix.httptest ADD ( `certfile` varchar(255) DEFAULT \u0026#39;\u0026#39; NOT NULL, `keyfile` varchar(255) DEFAULT \u0026#39;\u0026#39; NOT NULL, `keypass` varchar(64) DEFAULT \u0026#39;\u0026#39; NOT NULL, `capath` varchar(255) DEFAULT \u0026#39;\u0026#39; NOT NULL, `verifypeer` integer DEFAULT \u0026#39;0\u0026#39; NOT NULL, `verifyhost` integer DEFAULT \u0026#39;0\u0026#39; NOT NULL ); Como paso final, no olvides instalar/actualizar el frontend de zabbix con la versión modificada.\n¡Disfrútalo!\n","date":"11 de enero de 2014","permalink":"https://mamux.org/es/posts/zabbix-2.2-web-monitoring/","section":"Posts","summary":"","title":"Monitoreo web de Zabbix 2.2.x"},{"content":"Hoy en día puedes encontrar información sobre cómo compilar cruzadamente el kernel de Linux para un kurobox pro en la wiki de NAS central. Sin embargo, pensé que sería una buena idea reescribir este tutorial desde el punto de vista de un usuario de Debian. Es solo una forma más limpia y elegante de hacer lo mismo en un sistema Debian.\nEn primer lugar, tenemos que añadir un nuevo repositorio en el archivo /etc/apt/sources.list:\ndeb http://www.emdebian.org/debian/ squeeze main Este es el Proyecto Debian Embebido oficial donde puedes encontrar las toolchains precompiladas necesarias para compilar cruzadamente para muchas arquitecturas (arm, armel, ia64, m68k, mips, mipsel, powerpc, s390 y sparc).\nAhora tenemos que actualizar la información de nuestros repositorios e instalar la toolchain requerida:\napt-get update apt-get install libc6-armel-cross libc6-dev-armel-cross binutils-arm-linux-gnueabi gcc-4.4-arm-linux-gnueabi g++-4.4-arm-linux-gnueabi uboot-mkimage devio libncurses5-dev El siguiente paso es descargar el código fuente del kernel de Linux y crear una configuración por defecto para nuestra arquitectura:\nexport VERSION=\u0026#34;2.6.37\u0026#34; export ARCH=\u0026#34;arm\u0026#34; export CROSS_COMPILE=\u0026#34;arm-linux-gnueabi-\u0026#34; export INSTALL_MOD_PATH=\u0026#34;/tmp/kurobox\u0026#34; export KERN_DIR=\u0026#34;$INSTALL_MOD_PATH/boot\u0026#34; mkdir -p \u0026#34;${KERN_DIR}\u0026#34; wget \u0026#34;http://www.kernel.org/pub/linux/kernel/v2.6/linux-${VERSION}.tar.bz2\u0026#34; tar xjf linux-${VERSION}.tar.bz2 cd \u0026#34;linux-${VERSION}\u0026#34; make mrproper make orion5x_defconfig En este momento tenemos una configuración por defecto del kernel de Linux para nuestra plataforma Orion. Podemos personalizar nuestra configuración ejecutando \u0026lsquo;make menuconfig\u0026rsquo;. En mi caso quería añadir soporte para ext4 compilado directamente en mi sistema de archivos raíz de Debian y desmarcar todas las plataformas en \u0026lsquo;System Type -\u0026gt; Orion Implementations\u0026rsquo; excepto \u0026lsquo;Kurobox Pro\u0026rsquo; por supuesto.\nAhora compilaremos los módulos del kernel y construiremos la imagen final del kernel.\nmake modules make modules_install make zImage devio \u0026gt; foo \u0026#39;wl 0xe3a01c05,4\u0026#39; \u0026#39;wl 0xe38110e5,4\u0026#39; cat foo arch/arm/boot/zImage \u0026gt; ${KERN_DIR}/zImage rm foo mkimage -A arm -O linux -T kernel -C none -a 0x00008000 -e 0x00008000 -n \u0026#39;linux\u0026#39; -d \u0026#34;${KERN_DIR}/zImage\u0026#34; \u0026#34;${KERN_DIR}/uImage-${VERSION}\u0026#34; rm \u0026#34;${KERN_DIR}/zImage\u0026#34; cd \u0026#34;${INSTALL_MOD_PATH}\u0026#34; tar cjvf kurobox-kernel.tar.bz2 * Finalmente tenemos que copiar la imagen del kernel y los módulos a la kurobox e instalarlos:\nscp kurobox-kernel.tar.bz2 root@kurobox: ssh root@kurobox tar -C / -xjvf kurobox-kernel.tar.bz2 cd /boot rm uImage.buffalo ln -s uImage-2.6.37 uImage.buffalo depmod -a shutdown -r now Si algo sale mal puedes utilizar una consola serial para ver el proceso de arranque como se explica en nas-central. En mi caso utilizo un cable compatible DKU-5 hecho por mí mismo encontrado en dealextreme.\n","date":"11 de enero de 2011","permalink":"https://mamux.org/es/posts/kurobox-pro-kernel-cross-compilation/","section":"Posts","summary":"","title":"Compilación cruzada del kernel de Linux para Kurobox Pro"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/kernel/","section":"Tags","summary":"","title":"Kernel"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/kurobox/","section":"Tags","summary":"","title":"Kurobox"},{"content":"","date":null,"permalink":"https://mamux.org/es/tags/linux/","section":"Tags","summary":"","title":"Linux"},{"content":"","date":"1 de enero de 0001","permalink":"https://mamux.org/es/archives/","section":"mamux.org","summary":"archives","title":"Archivo"},{"content":"","date":"1 de enero de 0001","permalink":"https://mamux.org/es/search/","section":"mamux.org","summary":"search","title":"Buscar"},{"content":"","date":null,"permalink":"https://mamux.org/es/categories/","section":"Categories","summary":"","title":"Categories"}]