fraterneo GNU/Linux

Ollama en Fedora: Cómo instalarlo y usarlo desde el CLI, su API y Open WebUI

2026-04-09T15:59:00.001-04:00

En el contexto actual de la inteligencia artificial, cada vez es más relevante poder ejecutar modelos de lenguaje de forma local (on-premise), sin depender de servicios externos. Esto no solo mejora la privacidad, sino que también reduce costos y latencia. En este escenario, Ollama se posiciona como una de las herramientas más prácticas para ejecutar modelos LLM (Large Language Models) directamente en tu máquina.

Nota importante: Esta guía está pensada como un laboratorio de pruebas y aprendizaje, ideal para ejecutar Ollama en entornos de desarrollo (por ejemplo, una laptop o estación de trabajo con CPU multicore y 16 GB de RAM). Sin embargo, si el objetivo es obtener mejor rendimiento, menor latencia y capacidad de atender múltiples solicitudes, se recomienda utilizar hardware más robusto, especialmente una GPU dedicada (preferiblemente NVIDIA con al menos 12–24 GB de VRAM), junto con 32–64 GB de RAM y almacenamiento NVMe. Esta configuración permite aprovechar plenamente el potencial de los modelos de lenguaje y llevar la solución a un entorno más cercano a producción.

¿Qué es Ollama?

Ollama es un runtime local para modelos de inteligencia artificial, diseñado para facilitar la ejecución de modelos como LLaMA 3, Codex, Claude Code y asistentes como OpenClaw.

Funciona como un servidor local que expone una API REST, permitiendo ejecutar modelos sin conexión a la nube (previamente descargados), integrar IA en aplicaciones propias y automatizar tareas con lenguaje natural. Podemos interactuar con Ollama desde la línea de comandos, así también mediante Open WebUI (contenerizado).

Instalación de Ollama:

fraterneo@fedora:~$ curl -fsSL https://ollama.com/install.sh | sh
>>> Installing ollama to /usr/local
[sudo] password for fraterneo: 
>>> Downloading ollama-linux-amd64.tar.zst
######################################################################## 100.0%
>>> Creating ollama user...
>>> Adding ollama user to render group...
>>> Adding ollama user to video group...
>>> Adding current user to ollama group...
>>> Creating ollama systemd service...
>>> Enabling and starting ollama service...
Created symlink '/etc/systemd/system/default.target.wants/ollama.service' → '/etc/systemd/system/ollama.service'.
>>> The Ollama API is now available at 127.0.0.1:11434.
>>> Install complete. Run "ollama" from the command line.

Iniciar Ollama desde el CLI para que descargue llama3 (unos 5GB):

fraterneo@fedora:~$ ollama run llama3
pulling manifest 
pulling 6a0746a1ec1a: 100% ▕████████████████████████████████████████████████████▏ 4.7 GB                         
pulling 4fa551d4f938: 100% ▕████████████████████████████████████████████████████▏  12 KB                         
pulling 8ab4849b038c: 100% ▕████████████████████████████████████████████████████▏  254 B                         
pulling 577073ffcc6c: 100% ▕████████████████████████████████████████████████████▏  110 B                         
pulling 3f8eb4da87fa: 100% ▕████████████████████████████████████████████████████▏  485 B                         
verifying sha256 digest 
writing manifest 
success 
>>> Send a message (/? for help)

Interacción con un prompt sencillo:

fraterneo@fedora:~$ ollama run llama3
>>> dame una lista de hoteles economicos en Puerto Plata, RD
Aquí te dejo una lista de hoteles económicos en Puerto Plata, República Dominicana:

1. **Hotel Cortecito**: Un hotel con 24 habitaciones y suites a un precio asequible, ubicado en el corazón del centro histórico de
Puerto Plata. Precio: aproximadamente $40-$60 USD por noche.
2. **Hostal La Casa del Sol**: Un hostal con 12 habitaciones y una atmósfera relajada, situado en la zona céntrica de Puerto Plata.
Precio: aproximadamente $30-$50 USD por noche.
3. **Hotel Villa Colonial**: Un hotel con 25 habitaciones y suites, ubicado a pocos pasos del Malecón de Puerto Plata. Precio:
aproximadamente $40-$70 USD por noche.
4. **Casa Conde Hotel Puerto Plata**: Un hotel con 140 habitaciones y suites, situado en la playa de Puerto Plata. Precio:
aproximadamente $60-$100 USD por noche.
5. **Hotel La Residencia**: Un hotel con 16 habitaciones y suites, ubicado en el corazón del centro histórico de Puerto Plata. Precio:
aproximadamente $50-$80 USD por noche.
6. **Hostal El Jardín**: Un hostal con 10 habitaciones y una atmósfera agradable, situado en la zona céntrica de Puerto Plata. Precio:
aproximadamente $25-$40 USD por noche.
7. **Hotel Puerta del Mar**: Un hotel con 30 habitaciones y suites, ubicado en la playa de Puerto Plata. Precio: aproximadamente
$50-$80 USD por noche.
8. **Hostal La Casa de los Abuelos**: Un hostal con 6 habitaciones y una atmósfera familiar, situado en el corazón del centro
histórico de Puerto Plata. Precio: aproximadamente $20-$35 USD por noche.

Es importante tener en cuenta que los precios pueden variar dependiendo de la temporada y la disponibilidad, así que te recomiendo
verificar los precios y ofertas en los sitios web de cada hotel o hostal antes de hacer una reserva.

También es recomendable leer las reseñas y revisiones de otros viajeros para obtener una idea más precisa de la calidad del servicio y
las condiciones del hotel.

>>> Send a message (/? for help)

API de Ollama

Ollama expone su API REST en http://localhost:11434/api/generate, por lo que podemos realizar pruebas usando curl y enviar un prompt sencillo y esperar respuesta en la misma línea de comandos. Dicho prompt debe ir dentro de una estructura en formato .JSON y la respuesta del modelo también viene en ese mismo formato con muchos metadatos que en éste momento no nos interesan, así que lo filtraremos el campo response usando el comando jq.

fraterneo@fedora:~$ curl http://localhost:11434/api/generate -d '{ "model": "llama3", "prompt": "Explica en 50 palabras que es el Kernel Linux", "stream": false }' | jq '.response'
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  1048  100   951  100    97    101     10  0:00:09  0:00:09 --:--:--   298

"El kernel Linux es el núcleo del sistema operativo Linux. 
Es responsable de gestionar los recursos del sistema, como la memoria y los 
dispositivos, y de proporcionar servicios básicos como el manejo 
de procesos, la gestión de archivos y la comunicación con hardware."

¿Qué es Open WebUI?

Es una interfaz web de código abierto y autoalojada diseñada para interactuar con modelos de lenguaje y sistemas de IA. Su objetivo es ofrecer una alternativa ligera, personalizable y centrada en la privacidad a las plataformas comerciales de chat con IA.

Instalación de Docker:

fraterneo@fedora:~$ sudo dnf install -y docker
[sudo] password for fraterneo: 
Updating and loading repositories:
Repositories loaded.
Package                      Arch   Version                 Repository      Size
Installing:
 moby-engine                 x86_64 29.3.1-1.fc43           updates    103.8 MiB
Installing dependencies:
 container-selinux           noarch 4:2.247.0-1.fc43        updates     74.2 KiB
 containerd                  x86_64 2.1.6-1.fc43            updates     89.7 MiB
 docker-cli                  x86_64 29.3.1-1.fc43           updates     28.2 MiB
 libbsd                      x86_64 0.12.2-6.fc43           fedora     423.2 KiB
 libmd                       x86_64 1.1.0-8.fc43            fedora     102.8 KiB
 libnet                      x86_64 1.3-6.fc43              fedora     132.5 KiB
 libslirp                    x86_64 4.9.1-2.fc43            fedora     152.8 KiB
 moby-filesystem             noarch 29.3.1-1.fc43           updates      0.0   B
 pigz                        x86_64 2.8-7.fc43              fedora     163.0 KiB
 rootlesskit                 x86_64 2.3.6-2.fc43            updates     23.6 MiB
 runc                        x86_64 2:1.4.1-1.fc43          updates     10.3 MiB
 slirp4netns                 x86_64 1.3.1-3.fc43            fedora      89.3 KiB
 tini-static                 x86_64 0.19.0-11.fc43          fedora     774.1 KiB
Installing weak dependencies:
 criu                        x86_64 4.2-11.fc43             updates      1.6 MiB
 docker-buildx               x86_64 0.31.1-1.fc43           updates     92.9 MiB
 moby-engine-nano            noarch 29.3.1-1.fc43           updates    103.7 KiB
 moby-engine-rootless-extras noarch 29.3.1-1.fc43           updates     24.4 KiB

Transaction Summary:
 Installing:        18 packages

Total size of inbound packages is 90 MiB. Need to download 90 MiB.
After this operation, 352 MiB extra will be used (install 352 MiB, remove 0 B).
[ 1/18] pigz-0:2.8-7.fc43.x86_64        100% | 506.9 KiB/s |  95.3 KiB |  00m00s
[ 2/18] moby-filesystem-0:29.3.1-1.fc43 100% | 303.9 KiB/s |  16.1 KiB |  00m00s
[ 3/18] container-selinux-4:2.247.0-1.f 100% | 537.1 KiB/s |  58.0 KiB |  00m00s
[ 4/18] docker-cli-0:29.3.1-1.fc43.x86_ 100% |   4.3 MiB/s |   8.0 MiB |  00m02s
[ 5/18] tini-static-0:0.19.0-11.fc43.x8 100% |   3.2 MiB/s | 322.3 KiB |  00m00s
[ 6/18] runc-2:1.4.1-1.fc43.x86_64      100% |   5.6 MiB/s |   3.5 MiB |  00m01s
[ 7/18] moby-engine-nano-0:29.3.1-1.fc4 100% |   1.3 MiB/s |  56.8 KiB |  00m00s
[ 8/18] moby-engine-rootless-extras-0:2 100% | 619.3 KiB/s |  24.2 KiB |  00m00s
[ 9/18] rootlesskit-0:2.3.6-2.fc43.x86_ 100% |   4.9 MiB/s |   7.4 MiB |  00m02s
[10/18] moby-engine-0:29.3.1-1.fc43.x86 100% |   4.0 MiB/s |  22.4 MiB |  00m06s
[11/18] criu-0:4.2-11.fc43.x86_64       100% |   3.7 MiB/s | 579.4 KiB |  00m00s
[12/18] libbsd-0:0.12.2-6.fc43.x86_64   100% |   1.6 MiB/s | 122.5 KiB |  00m00s
[13/18] libnet-0:1.3-6.fc43.x86_64      100% |   1.1 MiB/s |  60.1 KiB |  00m00s
[14/18] libmd-0:1.1.0-8.fc43.x86_64     100% | 963.6 KiB/s |  47.2 KiB |  00m00s
[15/18] slirp4netns-0:1.3.1-3.fc43.x86_ 100% | 955.8 KiB/s |  46.8 KiB |  00m00s
[16/18] libslirp-0:4.9.1-2.fc43.x86_64  100% |   1.3 MiB/s |  78.6 KiB |  00m00s
[17/18] docker-buildx-0:0.31.1-1.fc43.x 100% |   5.6 MiB/s |  21.2 MiB |  00m04s
[18/18] containerd-0:2.1.6-1.fc43.x86_6 100% |   3.2 MiB/s |  26.2 MiB |  00m08s
--------------------------------------------------------------------------------
[18/18] Total                           100% |   9.4 MiB/s |  90.1 MiB |  00m10s
Running transaction
[ 1/20] Verify package files            100% |  82.0   B/s |  18.0   B |  00m00s
[ 2/20] Prepare transaction             100% |  93.0   B/s |  18.0   B |  00m00s
[ 3/20] Installing moby-filesystem-0:29 100% |  18.6 KiB/s | 400.0   B |  00m00s
[ 4/20] Installing docker-cli-0:29.3.1- 100% | 276.9 MiB/s |  28.2 MiB |  00m00s
[ 5/20] Installing libslirp-0:4.9.1-2.f 100% |  21.5 MiB/s | 154.3 KiB |  00m00s
[ 6/20] Installing slirp4netns-0:1.3.1- 100% |   6.3 MiB/s |  90.7 KiB |  00m00s
[ 7/20] Installing libmd-0:1.1.0-8.fc43 100% |  12.8 MiB/s | 104.5 KiB |  00m00s
[ 8/20] Installing libbsd-0:0.12.2-6.fc 100% |  51.8 MiB/s | 424.7 KiB |  00m00s
[ 9/20] Installing libnet-0:1.3-6.fc43. 100% |  26.2 MiB/s | 134.0 KiB |  00m00s
[10/20] Installing rootlesskit-0:2.3.6- 100% | 251.1 MiB/s |  23.6 MiB |  00m00s
[11/20] Installing runc-2:1.4.1-1.fc43. 100% | 149.2 MiB/s |  10.3 MiB |  00m00s
[12/20] Installing containerd-0:2.1.6-1 100% | 305.4 MiB/s |  89.8 MiB |  00m00s
[13/20] Installing tini-static-0:0.19.0 100% |  13.8 MiB/s | 775.4 KiB |  00m00s
[14/20] Installing container-selinux-4: 100% |   7.7 KiB/s |  77.8 KiB |  00m10s
[15/20] Installing pigz-0:2.8-7.fc43.x8 100% |   2.6 MiB/s | 164.5 KiB |  00m00s
>>> Running sysusers scriptlet: moby-engine-0:29.3.1-1.fc43.x86_64              
>>> Finished sysusers scriptlet: moby-engine-0:29.3.1-1.fc43.x86_64             
>>> Scriptlet output:                                                           
>>> Creating group 'docker' with GID 975.                                       
>>>                                                                             
[16/20] Installing moby-engine-0:29.3.1 100% | 429.7 MiB/s | 104.0 MiB |  00m00s
>>> Running %post scriptlet: moby-engine-0:29.3.1-1.fc43.x86_64                 
>>> Finished %post scriptlet: moby-engine-0:29.3.1-1.fc43.x86_64                
>>> Scriptlet output:                                                           
>>> Created symlink '/etc/systemd/system/sockets.target.wants/docker.socket' → '
>>>                                                                             
[17/20] Installing moby-engine-rootless 100% |   1.7 MiB/s |  24.8 KiB |  00m00s
[18/20] Installing criu-0:4.2-11.fc43.x 100% |  42.1 MiB/s |   1.6 MiB |  00m00s
[19/20] Installing docker-buildx-0:0.31 100% | 404.4 MiB/s |  93.0 MiB |  00m00s
[20/20] Installing moby-engine-nano-0:2 100% |  14.3 KiB/s | 104.4 KiB |  00m07s
Complete!

Habilitar/Iniciar el servicio de Docker:

fraterneo@fedora:~$ sudo systemctl enable --now docker.service
Created symlink '/etc/systemd/system/multi-user.target.wants/docker.service' → '/usr/lib/systemd/system/docker.service'.

Desplegar Open WebUI:

fraterneo@fedora:~$ sudo docker run -d --network=host -v open-webui:/app/backend/data -e OLLAMA_BASE_URL=http://127.0.0.1:11434 --name open-webui --restart always ghcr.io/open-webui/open-webui:main
Unable to find image 'ghcr.io/open-webui/open-webui:main' locally
main: Pulling from open-webui/open-webui
4f4fb700ef54: Pull complete 
c6aec87f9665: Pull complete 
84a2afebaf4d: Pull complete 
0ca4ca8e967f: Pull complete 
4afda7e4a767: Pull complete 
bb97a7af1971: Pull complete 
71c87fe6927a: Pull complete 
1076a6959a11: Pull complete 
ca10a397ad2d: Pull complete 
74ee6a0d91be: Pull complete 
cb6955fc6e74: Pull complete 
f4178cf3eeb9: Pull complete 
9846260f66de: Pull complete 
5801121de8a4: Pull complete 
8dc200665289: Pull complete 
3642169f0cc5: Download complete 
dd4723f56f9c: Download complete 
Digest: sha256:b8095f79a6a8ffad8f830bdacc9b5b0aef805689b31bca0b065cc2424d3cfaeb
Status: Downloaded newer image for ghcr.io/open-webui/open-webui:main
74a26297324121d30dbfdc4c1df99532aa148c7efd97f57fcd33dc15cd17c396

Accedemos a Open WebUI mediante el navegador http://localhost:8080

Páginal principal de Open WebUI en localhost

Creación del usuario administrador de Open WebUI

Listos para usar el modelo llama3 desde Open WebUI

Ollama es una herramienta clave para quienes desean llevar la inteligencia artificial al entorno local, permitiendo construir soluciones avanzadas sin depender de servicios externos. Su facilidad de instalación, junto con su API simple, lo convierten en una opción ideal tanto para desarrolladores como para profesionales de ciberseguridad que buscan control total sobre sus datos.

Si has tenido experiencia previa con Ollama y Open WebUI o éste es tu primer contacto con éstas tecnologías a través de ésta guía, deja tus inquietudes y comentarios mas abajo...

Referencias:

https://docs.ollama.com/linux

https://github.com/open-webui/open-webui

20 comandos Linux que debes dominar en 2026

2026-04-07T11:06:00.001-04:00

En un entorno donde Linux domina super-computadoras, servidores, cloud, ciberseguridad y DevOps, conocer los comandos esenciales ya no es opcional: Es una competencia básica para cualquier profesional de TI.

En este artículo aprenderás 20 comandos Linux fundamentales, explicados de forma práctica y orientados a uso real en 2026. Esta tabla funciona como una referencia rápida (cheat sheet) que puedes consultar en tu práctica diaria.

Los comandos seleccionados no son aleatorios. Representan el núcleo operativo de cualquier entorno Linux moderno, desde tareas básicas de navegación hasta administración de permisos y monitoreo del sistema.

Dominar este conjunto te permitirá ejecutar la mayoría de tareas esenciales sin depender de herramientas gráficas.

Además, en entornos profesionales trabajar desde la terminal no es una opción secundaria, sino el estándar. Por ello, esta tabla está diseñada con un enfoque práctico: Cada comando incluye un ejemplo realista y su uso más frecuente.

Dominar estos comandos no significa memorizarlos de forma aislada, sino integrarlos en tu flujo de trabajo diario. En Linux, la eficiencia proviene de la combinación de comandos, el uso de tuberías (pipes), completar con TAB y la automatización de tareas repetitivas.

A medida que avances, notarás que estos comandos básicos se convierten en la base para herramientas más avanzadas utilizadas en DevOps, ciberseguridad y administración de sistemas. Es precisamente este dominio fundamental lo que diferencia a un usuario ocasional de un profesional competente en entornos Linux.

En última instancia, aprender Linux no es solo aprender comandos, sino adoptar una forma de trabajar orientada a la eficiencia, el control y la automatización. Esta tabla es un punto de partida sólido; el siguiente paso es aplicarla constantemente en escenarios reales.

Cómo unir Ubuntu a Active Directory usando ADSys

2026-04-01T19:49:00.002-04:00

Esta guía te permitirá integrar Ubuntu (versiones 25.10 / 26.04) en un dominio de Active Directory gestionado por Samba 4 (también válido para dominios Windows), permitiendo no solo la autenticación centralizada, sino también la gestión de políticas de grupo mediante ADSys.

A parte de Samba 4, que no necesita presentación por aquí, ya que hay bastante material en éste blog sobre él; usaremos SSSD, que es el daemon que gestiona la autenticación local y el acceso a servicios de directorio remotos en GNU Linux. También usaremos realm, que es una herramienta simplificada para descubrir y unirse a dominios de AD sin configurar manualmente archivos complejos y ADSys, una solución de Canonical para gestionar clientes Ubuntu mediante GPOs (Objetos de Directiva de Grupo) de Active Directory.

Debemos asegurarnos que nuestro equipo cliente con Ubuntu se encuentra en la misma red del servidor AD (en nuestro caso es un AlmaLinux con Samba 4).

Unir Ubuntu al Dominio FCLD.LOCAL

Actualización e Instalación

Primero, actualizamos el sistema e instalamos los paquetes necesarios para la integración y la gestión de políticas.

fraterneo@ubuntu-client:~$ sudo apt update && sudo apt upgrade -y
fraterneo@ubuntu-client:~$ sudo apt install -y realmd sssd sssd-tools libnss-sss libpam-sss adcli adsys krb5-user smbclient samba-common-bin packagekit

*Durante el proceso de instalación Kerberos pide el realm del dominio, lo escribimos en mayúsculas: FCLD.LOCAL

Descubrimiento del Dominio

Verificamos que Ubuntu puede ver el dominio fcld.local y que identifica los paquetes requeridos.

fraterneo@ubuntu-client:~$ realm discover

fcld.local
  type: kerberos
  realm-name: FCLD.LOCAL
  domain-name: fcld.local
  configured: no
  server-software: active-directory
  client-software: sssd
  required-package: sssd-tools
  required-package: sssd
  required-package: libnss-sss
  required-package: libpam-sss
  required-package: adcli
  required-package: samba-common-bin

Unión al Dominio

Ejecutamos la unión oficial. Usaremos el parámetro -v (verbose) para ver el progreso detallado. El sistema solicitará la contraseña del administrador del dominio.

fraterneo@ubuntu-client:~$ sudo realm join -v --user=Administrator FCLD.LOCAL

 * Resolving: _ldap._tcp.fcld.local
 * Performing LDAP DSE lookup on: 10.42.0.1
 * Successfully discovered: fcld.local
Password for Administrator: 
 * Unconditionally checking packages
 * Resolving required packages
 * LANG=C /usr/sbin/adcli join --verbose --domain fcld.local --domain-realm FCLD.LOCAL --domain-controller 10.42.0.1 --login-type user --login-user Administrator --stdin-password
 * Using domain name: fcld.local
 * Calculated computer account name from fqdn: UBUNTU-CLIENT
 * Using domain realm: fcld.local
 * Sending NetLogon ping to domain controller: 10.42.0.1
 * Received NetLogon info from: sambapdc01.fcld.local
 * Wrote out krb5.conf snippet to /var/cache/realmd/adcli-krb5-7eOcHR/krb5.d/adcli-krb5-conf-Y0LkRU
 * Authenticated as user: Administrator@FCLD.LOCAL
 * Using GSS-SPNEGO for SASL bind
 * Looked up short domain name: FCLD
 * Looked up domain SID: S-1-5-21-87385115-388024416-2340584732
 * Received NetLogon info from: sambapdc01.fcld.local
 * Using fully qualified name: ubuntu-client
 * Using domain name: fcld.local
 * Using computer account name: UBUNTU-CLIENT
 * Using domain realm: fcld.local
 * Calculated computer account name from fqdn: UBUNTU-CLIENT
 * Generated 120 character computer password
 * Using keytab: FILE:/etc/krb5.keytab
 * Found computer account for UBUNTU-CLIENT$ at: CN=UBUNTU-CLIENT,CN=Computers,DC=fcld,DC=local
 * Trying to set computer password with Kerberos
 * Set computer password
 * Retrieved kvno '3' for computer account in directory: CN=UBUNTU-CLIENT,CN=Computers,DC=fcld,DC=local
 * Checking host/UBUNTU-CLIENT
 *    Added host/UBUNTU-CLIENT
 * Checking RestrictedKrbHost/UBUNTU-CLIENT
 *    Added RestrictedKrbHost/UBUNTU-CLIENT
 * Discovered which keytab salt to use
 * Added the entries to the keytab: UBUNTU-CLIENT$@FCLD.LOCAL: FILE:/etc/krb5.keytab
 * Added the entries to the keytab: host/UBUNTU-CLIENT@FCLD.LOCAL: FILE:/etc/krb5.keytab
 * Added the entries to the keytab: RestrictedKrbHost/UBUNTU-CLIENT@FCLD.LOCAL: FILE:/etc/krb5.keytab
 * /usr/sbin/update-rc.d sssd enable
 * /usr/sbin/service sssd restart
 * Successfully enrolled machine in realm

Configuración de Inicio de Sesión

Para que Ubuntu cree automáticamente una carpeta de inicio (/home/usuario@dominio) la primera vez que un usuario de AD inicie sesión:

fraterneo@ubuntu-client:~$ sudo pam-auth-update --enable mkhomedir

Optimización de SSSD

Debemos ajustar el archivo de configuración para definir cómo se comportarán los nombres de usuario y las rutas de las carpetas. Edítalo y asegúrate de que luzca así:

fraterneo@ubuntu-client:~$ sudo nano /etc/sssd/sssd.conf

[sssd]
domains = fcld.local
config_file_version = 2
services = nss, pam

[domain/fcld.local]
default_shell = /bin/bash
krb5_store_password_if_offline = True
cache_credentials = True
krb5_realm = FCLD.LOCAL
realmd_tags = manages-system joined-with-adcli
id_provider = ad
fallback_homedir = /home/%u@%d
ad_domain = fcld.local
use_fully_qualified_names = True
ldap_id_mapping = True
access_provider = ad
auth_provider = ad

Reinicia el sistema tras este paso para aplicar los cambios globales. Al regresar nos logueamos en Ubuntu como administrator@fcld.local y clave de administrator del dominio.

Gestión de Políticas

ADSys permite que el administrador de AD controle Ubuntu usando archivos .admx (plantillas de directiva).

Generar las Plantillas

Desde el cliente Ubuntu, generamos los archivos de política necesarios:

administrator@fcld.local@ubuntu-client:~$ adsysctl policy admx all

Subir Políticas al Servidor AD (Samba 4)

Utilizaremos smbclient para crear las rutas en el volumen SYSVOL del servidor y subir las plantillas. Esto permitirá que el Editor de Directivas de Grupo en Windows (o herramientas de Samba) reconozca las opciones de Ubuntu.

Crear directorios en el servidor:

administrator@fcld.local@ubuntu-client:~$ smbclient //sambapdc01/sysvol -U Administrator@FCLD.LOCAL -c 'mkdir "/fcld.local/Policies/PolicyDefinitions"'
administrator@fcld.local@ubuntu-client:~$ smbclient //sambapdc01/sysvol -U Administrator@FCLD.LOCAL -c 'mkdir "/fcld.local/Policies/PolicyDefinitions/en-US"'

Subir archivos .admx (plantilla principal) y .adml (archivo de idioma):

administrator@fcld.local@ubuntu-client:~$ smbclient //sambapdc01/sysvol -U Administrator@FCLD.LOCAL -c 'put "/home/administrator@fcld.local/Ubuntu.admx" "/fcld.local/Policies/PolicyDefinitions/Ubuntu.admx"'
Password for [Administrator@FCLD.LOCAL]:
putting file /home/administrator@fcld.local/Ubuntu.admx as \fcld.local\Policies\PolicyDefinitions\Ubuntu.admx (42374.5 kb/s) (average 42375.0 kb/s)

administrator@fcld.local@ubuntu-client:~$ smbclient //sambapdc01/sysvol -U Administrator@FCLD.LOCAL -c 'put "/home/administrator@fcld.local/Ubuntu.adml" "/fcld.local/Policies/PolicyDefinitions/en-US/Ubuntu.adml"'
Password for [Administrator@FCLD.LOCAL]:
putting file /home/administrator@fcld.local/Ubuntu.adml as \fcld.local\Policies\PolicyDefinitions\en-US\Ubuntu.adml (32838.6 kb/s) (average 32839.0 kb/s)

Validación de la Integración

Para confirmar que todo está funcionando correctamente, ejecuta estos tres comandos:

Estado del Realm:

administrator@fcld.local@ubuntu-client:~$ realm discover
fcld.local
  type: kerberos
  realm-name: FCLD.LOCAL
  domain-name: fcld.local
  configured: kerberos-member
  server-software: active-directory
  client-software: sssd
  required-package: sssd-tools
  required-package: sssd
  required-package: libnss-sss
  required-package: libpam-sss
  required-package: adcli
  required-package: samba-common-bin
  login-formats: %U@fcld.local
  login-policy: allow-realm-logins

Debería mostrar configured: kerberos-member.

Obtener Ticket de Kerberos:

administrator@fcld.local@ubuntu-client:~$ kinit administrator
Password for administrator@FCLD.LOCAL: 
Warning: Your password will expire in 36 days on Fri 08 May 2026 03:15:41 PM AST

Listar Tickets activos:

administrator@fcld.local@ubuntu-client:~$ klist
Ticket cache: FILE:/tmp/krb5cc_257600500_Yg6ycZ
Default principal: Administrator@FCLD.LOCAL

Valid starting       Expires              Service principal
04/01/2026 17:35:51  04/02/2026 03:35:51  krbtgt/FCLD.LOCAL@FCLD.LOCAL
	renew until 04/08/2026 17:35:51

Si ves un ticket para krbtgt/FCLD.LOCAL@FCLD.LOCAL, la comunicación segura está establecida.

Propiedades del equipo UBUNTU-CLIENT en AD Users and Computers

Puedes ampliar aún más sobre ADSys y lo que te permite hacer al manejar las políticas para Ubuntu desde Active Directory consultando la documentación oficial de Ubuntu sobre Group Policy, ADSys, Configuración de AD y Unión Manual.

Solución de Denegaciones de SELinux para virtquemud (acceso setattr) en AlmaLinux/RHEL

2026-03-27T16:33:00.004-04:00

Si utilizas libvirt (KVM/QEMU) para virtualizar en Fedora AlmaLinux, Rocky Linux o RHEL, es posible que estés viendo alertas frecuentes de SELinux al encender y apagar las máquinas virtuales. Al revisar las alertas de SELinux (sealert o /var/log/audit/audit.log), probablemente verás mensajes que indican que rpc-virtqemud está impidiendo el acceso a setattr en las imágenes de disco .qcow2.

A continuación, te explico por qué ocurre esto y cómo solucionarlo sin necesariamente desactivar SELinux.

Discrepancia en las etiquetas

SELinux es una capa de seguridad que utiliza etiquetas para determinar si un proceso (como el hipervisor QEMU) puede acceder a un archivo. El problema comienza cuando tenemos imágenes de disco .qcow2 en una ruta personal (diferente del pool por defecto ubicado /var/lib/libvirt/images) por lo que éstos archivos no están etiquetados correctamente (suelen tener etiquetas como admin_home_t o unlabeled_t).

El hipervisor espera que el archivo tenga una etiqueta específica: virt_image_t. Cuando las etiquetas no coinciden, SELinux bloquea el acceso, incluso si los permisos estándar (DAC) son extremadamente permisivos (chmod 777).

Reetiquetar el directorio

El SELinux Troubleshooter recomienda varias cosas, entre ellas reetiquetar el sistema de archivos completo (touch /.autorelabel), cosa que es muy extrema. También sugiere reetiquetar el archivo .qcow2, pero cuando son varios lo conveniente y funcional es hacer ese proceso al directorio completo.

Lo primero que haremos es agregar el directorio a la política de SELinux usando el comando semanage e indicándole la ruta a dicho directorio:

fraterneo@rainbow:~$ sudo semanage fcontext -a -t virt_image_t "~/KVM/(/.*)?"
Ahora aplicamos la etiqueta de manera recursiva al directorio en cuestión:
fraterneo@rainbow:~$ sudo restorecon -Rv ~/KVM/

Puedes confirmar que el proceso fue exitoso visualizando las etiquetas de SELinux:

fraterneo@rainbow:~$ ls -lZ ~/KVM/

Un paso no obligatorio pero muy recomendado es darle al usuario y grupo qemu la propiedad sobre los arhivos de imágenes:

fraterneo@rainbow:~$ sudo chown qemu:qemu ~/KVM/*.qcow2

Para aplicarlo a tu contexto solo debes reemplazar ~/KVM por la ruta personalizada que usas para tus imágenes de máquinas virtuales.

Si tienes preguntas sobre virtualización en GNU Linux o resolución de problemas en SELinux, déjame saber en los comentarios...

Cómo configurar una memoria USB multiboot con 30+ distribuciones GNU Linux - Parte 4

2026-03-20T14:08:43.024-04:00

Bienvenidos a la cuarta entrega de ésta serie para crear una memoria USB Multiboot artesanal. A continuación les dejaré la lista de distribuciones que colocaremos en el dispositivo USB y el enlace de descarga para cada una. En las partes subsiguientes veremos mediante video-tutoriales cómo configurar al menos una distribución de cada categoría (hacking, desktops, servers, minidistros, etc.).

Distribuciones para USB Multiboot

¡La lista es genial y bastante larga! Las 52 distribuciones listadas fueron probadas exitosamente en el Multiboot, sin embargo, puedes elegir solo las que prefieras o las que tengas capacidad de colocar según el espacio disponible en tu dispositivo USB.

En el ejemplo de la Parte 2 trabajamos con una memoria USB que tenía un espacio disponible de 114.6 GB. Actualmente dispongo de un disco de 512 GB en el que caben perfectamente las 52 distros de la lista. La idea es que te ajustes a la capacidad que tengas.

Puedes ir descargándolas y preparándote para los videos que vienen...

Xterm: el emulador de terminal más potente… y más incomprendido

2026-03-18T17:08:00.001-04:00

Cuando se habla de terminales en GNU Linux, la mayoría de usuarios menciona opciones modernas como GNOME Terminal, Konsole, Terminator o Tilix. Sin embargo, detrás de todos ellos existe un veterano que sigue siendo una referencia técnica: xterm.

A pesar de su estabilidad, potencia y longevidad, xterm suele ser subutilizado e incluso temido por muchos usuarios. En este artículo analizamos por qué ocurre esto, qué ventajas reales ofrece y cómo configurarlo para hacerlo más amigable.

¿Qué es xterm y por qué sigue siendo relevante?

xterm es uno de los emuladores de terminal más antiguos del ecosistema Unix/Linux, desarrollado originalmente para el sistema X Window. Es considerado una implementación de referencia del estándar VT102/VT220, lo que lo convierte en una herramienta extremadamente compatible y confiable.

A diferencia de otros terminales modernos, xterm:

Tiene muy pocas dependencias
Es extremadamente ligero
Es altamente configurable mediante recursos X (Xresources)

¿Por qué xterm es subutilizado y temido? Existen varias razones obvias:

Interfaz “antigua”

xterm no incluye pestañas, transparencias, perfiles gráficos modernos. Esto hace que muchos lo perciban como “obsoleto”, cuando en realidad es minimalista por diseño.

Configuración poco intuitiva

A diferencia de otros terminales que usan interfaces gráficas, xterm se configura mediante el fichero ~/.Xresources. Esto requiere conocimientos adicionales, lo que genera rechazo inicial.

Apariencia por defecto poco amigable

Sin configuración, xterm suele presentar tipografía básica, colores limitados y scroll incómodo. Esto crea una mala primera impresión.

Falta de descubribilidad

Muchas de sus funciones avanzadas no están documentadas de forma accesible y no son evidentes en el uso diario.

Ventajas reales de xterm

A pesar de todo lo visto anteriormente, xterm tiene ventajas que muchos terminales modernos no igualan:

Rendimiento extremo: xterm es más rápido, más liviano y más estable en entornos limitados; ésto lo hace dial para máquinas virtuales, sistemas antiguos y entornos de rescate.

Compatibilidad total: Muchos programas CLI están diseñados pensando en xterm. Esto reduce problemas con ncurses, vim y aplicaciones legacy.

Configuración extremadamente granular: A través de Xresources puedes controlar tipografía y su color, tamaño del texto, comportamiento del scroll, selección de texto y teclado.

Menor superficie de ataque: Menos dependencias implica menos vulnerabilidades y menos código innecesario.

Cómo hacer xterm más amigable

Aspecto original de xterm.

1. Crear el fichero de configuración:

fraterneo@rainbow:~$ touch ~/.Xresources

2. Aplicar una configuración base moderna:

fraterneo@rainbow:~$ nano ~/.Xresources
XTerm*faceName: Monospace
XTerm*faceSize: 11

XTerm*background: #1e1e1e
XTerm*foreground: #d4d4d4

XTerm*cursorColor: #00ff00

XTerm*scrollBar: true
XTerm*rightScrollBar: true
XTerm*saveLines: 5000

XTerm*termName: xterm-256color

XTerm*selectToClipboard: true

3. Aplicar cambios:

fraterneo@rainbow:~$ xrdb -merge ~/.Xresources

4. Cierra xterm y lo abres nuevamente:

Aspecto de xterm luego de aplicar la configuración.

Referencias:

https://xterm.dev/

https://en.wikipedia.org/wiki/Xterm

Cómo configurar una memoria USB multiboot con 30+ distribuciones GNU Linux - Parte 3

2026-03-17T15:31:00.002-04:00

Bienvenidos a la tercera parte de ésta serie de publicaciones que tiene el objetivo de crear una memoria USB Multiboot artesanal. En ésta entrega vamos a preparar y explicar los ficheros de configuración de GRUB2 y de Syslinux, cuyo contenido es que determina el orden del menú principal y de los sub-menus, así como su aspecto visual, fondo y tiempo de espera.

Manos a la obra...

El fichero grub.cfg

El mismo se encuentra en la ruta /mnt/multiboot/boot/grub2/grub.cfg que es donde montamos el dispositivo USB. Puedes usar tu editor preferido, yo usaré nano:

fraterneo@rainbow:~$ nano /mnt/multiboot/boot/grub2/grub.cfg

#INSERCIÓN DE MÓDULOS NECESARIOS
insmod chain
insmod png
insmod part_msdos
insmod fat
insmod ntfs
insmod syslinuxcfg
insmod cpuid
insmod ext2
insmod all_video
insmod configfile
insmod normal
insmod linux
insmod echo
insmod search
insmod regexp

#TIEMPO DE ESPERA DEL MENÚ PARA INICIAR LA OPCIÓN POR DEFECTO
set timeout=190

#TIPOGRAFÍA Y ESTILO DEL MENÚ SEGÚN SE CARGUE EN BIOS O EFI
insmod font
if loadfont /boot/grub2/fonts/unicode.pf2 ; then
#if loadfont unicode ; then
	# Use shift key to avoid loading gfxterm
	if keystatus --shift ; then true ; else
        if [ "${grub_platform}" == "efi" ]; then
            insmod efi_gop
            insmod efi_uga
        else
            insmod vbe
            insmod vga
            insmod gfxterm
            terminal_output gfxterm 
            if terminal_output gfxterm ; then true ; else
                terminal gfxterm
            fi
        fi
        insmod gfxterm
	fi
fi
set color_normal=white/black
set color_highlight=white/light-blue
export color_normal
export color_highlight


#IMAGEN DE FONDO Y RESOLUSIÓN DE LA PANTALLA
set gfxmode=800x600
set gfxpayload=keep
background_image /boot/background.png

#ENTRADA DE MENÚ PARA REINICIAR LA PC
menuentry "System Reboot" {
	reboot
}


#MOSTRAR LA OPCION DE CARGAR SYSLINUX SI SE INICIÓ EN BIOS
if [ ${grub_platform} == "pc" ]; then
	menuentry "Load Syslinux Boot Loader" {
    		set root=(hd0,msdos1)
    		chainloader +1
	}
fi

#ENTRADA PARA INICIAR DESDE DISCO LOCAL
menuentry "Boot from internal disk (UEFI)" --class reboot {
	set root=(hd1)
	chainloader +1
}

A continuación coloco la imagen para el fondo. Puedes usar otra que prefieras, verifica qué resolución tiene y ajustas el parámetro set gfxmode=800x600 para que coincida con la misma. De lo contrario, GRUB ignora la imagen y se muestra sin fondo. Dicha imagen debes colocarla en la ruta /boot/ del dispositivo USB.

El fichero syslinux.cfg

El mismo se encuentra en la ruta /mnt/multiboot//boot/syslinux/syslinux.cfg

fraterneo@rainbow:~$ sudo nano /mnt/multiboot/boot/syslinux/syslinux.cfg

#CONFIGURACION DE COLORES Y FONDO DEL MENÚ
DEFAULT 		    vesamenu.c32
PROMPT 		    0
TIMEOUT 		    1200
MENU COLOR BORDER       0 #ffffffff #ee000000 std
MENU COLOR TITLE 	    0 #ffffffff #ee000000 std
MENU COLOR SEL 	    0 #ffffffff #85000000 std
MENU COLOR UNSEL 	    0 #ffffffff #ee000000 std
MENU COLOR PWDHEADER    0 #ff000000 #99ffffff rev
MENU COLOR PWDBORDER    0 #ff000000 #99ffffff rev
MENU COLOR PWDENTRY     0 #ff000000 #99ffffff rev
MENU COLOR HOTKEY 	    0 #ff00ff00 #ee000000 std
MENU COLOR HOTSEL 	    0 #ffffffff #85000000 std
MENU ROWS 		    12
MENU VSHIFT 		    3
MENU RESOLUTION 	    800 600
MENU BACKGROUND 	    /boot/background.png
MENU TITLE 		    fraterneo's GNU/Linux USB Multiboot v2.0


#OPCION DE MENU PARA INICIO DESDE EL DISCO LOCAL
LABEL boot-local
MENU LABEL Boot from Local Disk
	COM32 chain.c32
	APPEND hd1
MENU DEFAULT


#OPCION DE MENU PARA CARGAR GRUB2
LABEL grub2
MENU LABEL Load GRUB2 Boot Loader
	KERNEL /boot/grub2/i386-pc/lnxboot.img
	INITRD /boot/grub2/i386-pc/core.img

En ésta tercera entrega preparamos los ficheros de configuración para GRUB2 y Syslinux. Si has seguido las partes uno y dos de ésta serie, puedes probar booteando desde el dispositivo USB para confirmar que está funcionando de la manera esperada. De la cuarta parte en adelante comenzaremos a agregar las distribuciones de GNU Linux (al menos una por cada categoría).

Si tienes alguna duda o sugerencia, no dudes dejármelo saber en los comentarios.

Referencias:

https://wiki.syslinux.org/wiki/index.php?title=Menu

https://www.gnu.org/software/grub/manual/grub/grub.html

El salto al Kernel 7

2026-03-16T13:48:00.002-04:00

El salto a la versión 7.0 del kernel de Linux (previsto para mediados de abril de 2026) no se debe a un cambio técnico revolucionario o a un salto en otra dirección, sino a una curiosa tradición personal del creador y rey supremo del Kernel: Linus Torvalds.

La regla de los "dedos de las manos y los pies"

Linus Torvalds tiene una política de numeración muy particular: No le agradan los números de versión grandes. Cuando el segundo dígito (la versión menor) llega a un punto en el que empieza a ser difícil de contar o recordar, decide saltar al siguiente número entero.

Distribuciones para USB Multiboot

En sus propias palabras durante el anuncio de la versión 6.19 (el pasado mes de Febrero), mencionó que se estaba quedando sin "dedos en las manos y en los pies" para seguir contando, por lo que la siguiente versión debía ser la 7.0.

Es el mismo criterio que usó para saltar de la 4.20 a la 5.0 y de la 5.19 a la 6.0.

Evitar confusión

Para el equipo de desarrollo, mantener versiones como "6.45" o "6.80" resulta confuso y poco práctico. Al reiniciar el contador en 7.0, el esquema de nombres se mantiene simple y fácil de seguir para los mantenedores de las distintas distribuciones.

Novedades a esperar en la versión 7.0

El Kernel se encuentra actualmente en el 7.0-rc4 y aunque el número no signifique un cambio de base, la versión 7.0 llega con hitos importantes para el ecosistema:

Consolidación de Rust: El soporte para el lenguaje Rust deja de ser "experimental" y se convierte en una parte permanente y reconocida del núcleo para mejorar la seguridad de la memoria.
Soporte de hardware de próxima generación: Incluye compatibilidad inicial para futuras arquitecturas como Intel Nova Lake y AMD Zen 6.
Mejoras en rendimiento: Optimizaciones significativas en sistemas de archivos (como exFAT y EXT4) y mejoras en la gestión térmica para portátiles modernos.

Referencias:

https://www.phoronix.com/news/Linux-7.0-Is-Next

https://www.linux-magazine.com/Online/News/The-Next-Linux-Kernel-Turns-7.0

Cómo configurar una memoria USB multiboot con 30+ distribuciones GNU Linux - Parte 2

2026-03-07T14:39:00.001-04:00

Continuando con este interesante proyecto, en esta segunda parte veremos el proceso de preparación del dispositivo USB y la configuración de los dos gestores de arranque que tendrá la misma (GRUB2 y Syslinux).

Manos a la obra...

Preparación del dispositivo USB

ADVERTENCIA: LOS COMANDOS QUE USAREMOS A CONTINUACIÓN ELIMINAN PARTICIONES Y DATOS EXISTENTES EN EL DISPOSITIVO USB. POR LO QUE ES IMPORTANTE IDENTIFICARLO PREVIAMENTE ASEGURÁNDONOS DE QUE ESTAMOS TRABAJANDO SOBRE EL DISPOSITIVO DESTINADO PARA ESTE PROYECTO.

Para identificar nuestro dispositivo en /dev usaremos el comando lsblk:

fraterneo@rainbow:~$ lsblk
NAME                                          MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS
sda                                             8:0    1 114.6G  0 disk

La salida del comando mostró varios dispositivos, de los cuales solo estoy mostrando sda. Por lo que en los comandos subsiguientes todo apuntará a /dev/sda para crear las particiones /dev/sda1 y /dev/sda2. La salida del comando lsblk no muestra nada en MOUNTPOINTS y debe ser así ya que si esta montado no será posible trabajar sobre él. Si tu dispositivo se encuentra montado debes desmontarlo usando el comando umount.

Eliminamos del dispositivo cualquier filesystem existente:

fraterneo@rainbow:~$ sudo wipefs -a /dev/sda

Dado que el dispositivo cuenta con un espacio de 114.6G, crearemos las dos particiones para que cada una cuente con el 50% del almacenamiento disponible (más o menos):

fraterneo@rainbow:~$ sudo parted /dev/sda --script mklabel msdos
fraterneo@rainbow:~$ sudo parted /dev/sda --script mkpart primary fat32 1MiB 62GiB
fraterneo@rainbow:~$ sudo parted /dev/sda --script mkpart primary ext4 62GiB 100%

Creamos los filesystems en las particiones correspondientes, FAT32 para sda1 y Ext4 para sda2. Incluimos la opción -E root_owner=$UID:$GUID en la creación del filesystem Ext4, asignando como propietario al usuario del entorno actual, para evitar inconvenientes con los permisos a la hora de crear archivos en dicha partición:

fraterneo@rainbow:~$ sudo mkfs.vfat -F32 -n multiboot /dev/sda1
fraterneo@rainbow:~$ sudo mkfs.ext4 -L iso -E root_owner=$UID:$GID /dev/sda2

Aprovechamos completamente el tamaño del filesystem Ext4, pasando a 0 el espacio reservado (el mismo no es necesario cuando se usa solo para almacenamiento):

fraterneo@rainbow:~$ sudo tune2fs -m 0 /dev/sda2

Instalación de GRUB2

Montamos la partición sda1:

fraterneo@rainbow:~$ sudo mount /dev/sda1 /mnt

Instalamos GRUB2 para EFI:

fraterneo@rainbow:~$ sudo grub2-install --target=x86_64-efi --removable --efi-directory=/mnt/multiboot/ --boot-directory /mnt/multiboot/boot --no-nvram --force

Instalamos GRUB2 para BIOS (Legacy Support):

fraterneo@rainbow:~$ sudo grub2-install --target=i386-pc --removable --boot-directory /mnt/multiboot/boot /dev/sda

Por alguna razón grub2-install no copia el archivo lnxboot.img, pero lo haremos manualmente:

fraterneo@rainbow:~$ cp /usr/lib/grub/i386-pc/lnxboot.img /mnt/multiboot/boot/grub2/i386-pc/

Lo podríamos dejar hasta éste punto y todo funcionaría bien: GRUB2 como gestor de arranque tanto para EFI como para BIOS. Sin embargo, agregaremos el gestor de arranque Syslinux (sólo funciona para BIOS) y dentro de él una opción en el menú para cargar GRUB2 y, dentro de GRUB2 una opción en el menú para volver a Syslinux.

Instalación de Syslinux

Creamos el directorio donde residirá Syslinux. Si no tienes Syslinux instalado en tu distribución, puedes buscarlo en el gestor de aplicaciones, instalarlo, localizar dónde fue instalado y sustituir las rutas en donde sea necesario:

fraterneo@rainbow:~$ sudo mkdir /mnt/multiboot/boot/syslinux

Instalamos Syslinux en su ruta y también lo copiamos al MBR:

fraterneo@rainbow:~$ sudo syslinux --install --directory boot/syslinux /dev/sda1
fraterneo@rainbow:~$ sudo dd if=/usr/share/syslinux/mbr.bin of=/dev/sda bs=440 count=1

Agregamos los demás archivos de Syslinux necesarios para su funcionamiento:

fraterneo@rainbow:~$ cp /usr/share/syslinux/chain.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/memdisk /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/menu.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/vesamenu.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/libcom32.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/libutil.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/reboot.c32 /mnt/multiboot/boot/syslinux/
fraterneo@rainbow:~$ cp /usr/share/syslinux/libmenu.c32 /mnt/multiboot/boot/syslinux/

Finalmente establecemos el boot flag del dispositivo USB, sin ésto no hay arranque:

fraterneo@rainbow:~$ sudo parted /dev/sda set 1 boot on

En ésta segunda parte vimos cómo preparar nuestro dispositivo para éste proyecto estableciendo las particiones y sus respectivos filesystems. También instalamos GRUB2, tanto para EFI como para BIOS (legacy), instalamos Syslinux (un gestor de arranque BIOS legacy) desde el que nos podremos mover a GRUB2 legacy y viceversa.

Para la siguiente entrega veremos los archivos de configuración de GRUB2 y Syslinux y la estructura de directorios que vamos a formar para comenzar a colocar las distribuciones y sus respectivas entradas en los menús de los gestores de arranque.

Si tienes alguna duda o sugerencia, no dudes dejármelo saber en los comentarios.

DAXFS: El nuevo sistema de archivos para memoria persistente

2026-02-18T12:50:00.003-04:00

Linux evoluciona constantemente, y una de las apuestas más interesantes para almacenamiento ultrarrápido es DAXFS, un sistema de archivos diseñado específicamente para memoria persistente (PMEM).

Fue anunciado por Cong Wang en LWN a finales de Enero de éste mismo año y a diferencia de los sistemas tradicionales que dependen de la jerarquía de bloques, DAXFS aprovecha el acceso directo a memoria (Direct Access / DAX) para permitir que los datos se lean y escriban sin pasar por el caché de página del kernel ni por el buffer de bloque. Esto reduce latencia, mejora el rendimiento y extiende la vida útil del hardware.

Algunas características claves de DAXFS:

Acceso directo a memoria persistente: Reduce los saltos y operaciones redundantes que frenan a sistemas tradicionales como ext4 o XFS.
Integrado con Linux moderno: Se está desarrollando activamente dentro de la comunidad, con soporte creciente en el árbol del kernel y repositorios como multikernel/daxfs en GitHub.
Diseñado para nuevas arquitecturas de almacenamiento: Ideal para cargas de trabajo de base de datos, sistemas de alto rendimiento o entornos donde la latencia importa.

Aunque todavía está en fases tempranas comparado con sistemas de archivos maduros, DAXFS representa un paso importante hacia tecnologías que aprovechan al máximo la memoria persistente, abriendo la puerta a implementaciones mucho más rápidas y eficientes.

Sigue ampliando en:

https://www.phoronix.com/news/DAXFS-Linux-File-System

https://www.linux.se/daxfs-ett-nytt-linux-filsystem-som-laser-direkt-ur-minnet/

Crédito de la imagen:

https://www.linux.se/daxfs-ett-nytt-linux-filsystem-som-laser-direkt-ur-minnet/

Cómo configurar una memoria USB multiboot con 30+ distribuciones GNU Linux - Parte 1

2026-02-10T16:48:00.002-04:00

Sí, ya sé. Muchos se preguntan por qué, en tiempos de Cloud Computing, Inteligencia Artificial y demás; es relevante tener a mano una memoria USB con múltiples distribuciones de GNU Linux y sobre todo creada artesanalmente... Les puedo dar muchas razones, sin embargo a lo largo de ésta serie de publicaciones (porque ésto va para largo) las irán descubriendo. Solo les diré que lo que haremos será la "Navaja Suiza" de todo linuxero empedernido.

Manos a la obra...

Primero lo primeo, teoría y explicaciones:

Sabemos de IONOS (2022) que "Un USB multiboot es una herramienta universal para reiniciar o reparar el sistema o para arrancar un sistema live desde una memoria USB. La ventaja de la también llamada memoria USB multiarranque es que en ella se pueden almacenar varias distribuciones de Windows y Linux, herramientas de reparación y rescate de servicios antivirus o sistemas live completos o copias de seguridad. Esto es posible gracias a herramientas de software gratuitas que, a diferencia de herramientas como Rufus, no crean una memoria USB de arranque por sistema, sino un USB de arranque múltiple para varios archivos."

Es importante aclarar que aunque es posible tener Windows y otros sistemas operativos como los de la familia BSD y los sobrevivientes de la familia Solaris; nos concentraremos exclusivamente en agregar a la memoria USB multitboot distribuciones de GNU Linux. Bueno, no tan exclusivamente, pues tenemos a mano un port de Android para PC llamado Android-x86 el cual agregaremos.

Gestor de arranque (boot loaders) y Sector de arranque (boot sector):

Tal como nos ilumina Advinium (2020) "Un USB booteable es una memoria preparada con un sector de arranque y un bootloader para que el ordenador pueda iniciar directamente desde ella. Al encender el equipo, la BIOS/UEFI lee este sector, carga el gestor de arranque y ejecuta el sistema operativo o herramienta que contiene, permitiendo instalar, reparar o arrancar un sistema sin usar el disco duro."

Aunque existen varias metodologías para bootear (arrancar) desde una memoria USB multiboot, es muy similar al arranque desde un disco fijo:

Aunque no abundaremos en los gestores de arranque, cabe menciona que existe una amplia gama para los diferentes medios de arranque: La familia SYSLINUX: memdisk (MS-DOS), isolinux (ISO 9660), pxelinux (PXE network), extlinux (ext2/3/4, btrfs y xfs) y syslinux (FAT y NTFS); LILO (gestor de arranque Linux ya descontinuado) y, por supesto, el universalmente usado: GRUB.

GRUB2: GNU GRand Unified Bootloader fue lanzado en 1995 por el proyecto GNU y es el gestor de arranque ampliamente usado en las distribuciones de GNU Linux y Solaris. Soporta arranque legacy (BIOS) y arranque en UEFI (Wikipedia, 2025).

SYSLINUX: Éste gestor de arranque "no se usa normalmente para arrancar instalaciones de Linux completas ya que Linux no suele instalarse en sistemas de archivos FAT. En cambio, se utiliza con frecuencia para discos flexibles de arranque o de rescate, LiveUSBs, u otros sistemas de arranque ligeros." (Wikipedia, 2025).

Cabe destacar la existencia de varios proyectos y aplicaciones que logran de forma muy automatizada (pero que no siempre funciona para una que otra distro) configurar una memoria USB multiboot. De manera resumida los menciono a continuación, ya que gracias al estudio de cómo trabajan he podido crear manualmente mi propia USB multiboot con más de 30 distribuciones de GNU Linux:

Multisystem (descontinuado)

Multibootusb (desactualizado)

Multiboot USB

Ventoy

YUMI

Para finalizar esta primera entrega, les recomiendo conseguir una memoria USB de la capacidad equivalente (o un poco más) en almacenamiento al tamaño de la suma de todas las distros que quieren agregarle. En mi caso particular usé una memoria de USB de 128GB; sin embargo es posible hacerlo con un disco duro que no estés usando y que esté en buenas condiciones (le haces un chequeo con SMART), o un dispositivo M.2 dentro de un enclosure.

Otro aspecto muy importante es particionar el dispositivo de almacenamiento (50/50), ya que el gestor de arranque (sea GRUB o Syslinux) debe residir en la primera partición y ésta debe tener un filesystem FAT32, el cual, lamentablemente, tiene un límite de tamaño de archivos de 4GB; lo que hace imposible colocar distros de gran tamaño (Parrot, Kali, Blackarch, Ubuntu Budgie, Winux, etc.). Para las distros de gran tamaño usaremos la segunda partición con un filesystem NTFS o Ext4.

En mi caso quedó de la siguiente manera:

Referencias:

https://www.ionos.com/es-us/digitalguide/servidores/herramientas/multiboot-usb/

https://www.advinium.com/1-blog/para-que-sirve-una-memoria-usb-booteable.htm#!

https://www.deskdecode.com/what-is-boot-booting-and-bootable-devices/

https://es.wikipedia.org/wiki/Syslinux

https://es.wikipedia.org/wiki/GNU_GRUB

https://es.wikipedia.org/wiki/Multiboot_Specification

https://es.wikipedia.org/wiki/Lilo_(Linux)

3 distribuciones de GNU/Linux para migrar desde Windows con facilidad

2026-01-14T12:25:00.002-04:00

El anuncio del fin del soporte oficial de Windows 10 a Octubre del 2025, marca un punto de inflexión para millones de usuarios en todo el mundo. Desde esa fecha, los sistemas que continúen utilizando este sistema operativo están expuestos a vulnerabilidades de seguridad, fallos sin parches y problemas de compatibilidad con nuevo software. Para muchos, la alternativa natural parece ser Windows 11, pero esta transición no está exenta de obstáculos.

Windows 11 impone requisitos de hardware más estrictos, como TPM 2.0, procesadores relativamente recientes y mayores demandas de memoria y almacenamiento. Esto deja fuera a una gran cantidad de equipos perfectamente funcionales, obligando a los usuarios a invertir en nuevo hardware o asumir riesgos de seguridad. A esto se suma el costo económico de licencias, actualizaciones y el consumo creciente de recursos del sistema, que afecta directamente el rendimiento en equipos media y baja gama.

En este contexto, GNU/Linux se presenta como una alternativa real, madura y accesible. Lejos quedó la idea de que Linux es solo para expertos (esa etapa muchos la vivimos). Hoy existen distribuciones diseñadas específicamente para facilitar la migración desde Windows, manteniendo una experiencia familiar, estable y eficiente. A continuación, te presento tres distribuciones que destacan por su enfoque amigable para nuevos usuarios.

WinuxOS: Una experiencia familiar desde el primer arranque

WinuxOS (antes conocida como Wubuntu y LinuxFX) está claramente orientada a usuarios provenientes de Windows. Su entorno de escritorio busca reducir la curva de aprendizaje, ofreciendo una disposición de menú, paneles y accesos que resultan inmediatamente reconocibles. Esto permite que el usuario pueda comenzar a trabajar desde el primer momento sin necesidad de reaprender conceptos básicos.

Entre sus principales bondades se encuentran un buen soporte de hardware, estabilidad en el sistema y una cuidada selección de aplicaciones preinstaladas que cubren las necesidades más comunes: navegación web, ofimática, multimedia y utilidades del sistema. WinuxOS es una opción ideal para quienes desean migrar sin sentirse “fuera de lugar”.

AnduinOS: Ligereza, simplicidad y enfoque práctico

AnduinOS destaca por su ligereza y eficiencia, convirtiéndose en una excelente alternativa para equipos con recursos limitados o hardware antiguo. Su diseño prioriza el rendimiento sin sacrificar usabilidad, lo que se traduce en un sistema rápido, estable y fácil de mantener.

El entorno es limpio, intuitivo y enfocado en la productividad diaria. AnduinOS ofrece una experiencia sólida para usuarios domésticos, estudiantes y profesionales que buscan un sistema confiable para tareas cotidianas, sin la sobrecarga típica de sistemas operativos comerciales. Es una demostración clara de que no se necesita hardware moderno para tener un sistema operativo moderno.

VailuxOS: Estabilidad, seguridad y enfoque europeo

VailuxOS se presenta como una distribución robusta, con un fuerte énfasis en la estabilidad y la seguridad. Su desarrollo sigue estándares rigurosos (como alemana que es, era de esperarse), lo que la convierte en una opción atractiva tanto para usuarios finales como para entornos profesionales.

Aunque mantiene una interfaz accesible, VailuxOS apuesta por ofrecer un sistema bien estructurado, confiable y preparado para el uso prolongado. Es ideal para quienes buscan dejar atrás Windows no solo por motivos de rendimiento, sino también por control, privacidad y soberanía tecnológica.

Reflexión final

La salida de Windows 10 no debería verse únicamente como un problema, sino como una oportunidad para replantear nuestra relación con la tecnología. GNU/Linux ofrece libertad, eficiencia y control, sin imponer costos innecesarios ni exigir hardware nuevo para funcionar correctamente.

Distribuciones como WinuxOS, AnduinOS y Vailux demuestran que migrar desde Windows es hoy más sencillo que nunca. La decisión de cambiar no solo impacta el rendimiento de nuestros equipos, sino también nuestra autonomía como usuarios. En un mundo donde el software cada vez impone más restricciones, elegir Linux es apostar por un ecosistema abierto, sostenible y centrado en el usuario.

Si después de leer este artículo tienes dudas, necesitas orientación para migrar desde Windows o deseas acompañamiento en la instalación y configuración de alguna de estas distribuciones GNU/Linux, puedes contactarme a través de mis cuentas de redes sociales enlazadas en este blog. Con gusto estaré compartiendo recomendaciones, buenas prácticas y soluciones adaptadas a tus necesidades y a las características de tu equipo.

Referencias:

https://www.linux.org/threads/winux-11-a-linux-distribution-designed-for-windows-users.58122/

https://www.muylinux.com/2025/05/13/anduinos-windows-microsoft/

https://www.linuxlinks.com/vailuxos-debian-based-linux-distribution/

Fedora 43: Resolviendo problemas con los thumbnailers en SELinux (thumb_t)

2025-12-29T14:46:00.001-04:00

En sistemas GNU/Linux que cuentan con SELinux para Control de Acceso Mandatorio (MAC), como Fedora o RHEL, algunos usuarios experimentan problemas con los generadores de miniaturas (thumbnailers) en gestores de archivos como Nautilus, Nemo o Thunar. Las carpetas con documentos PDF, imágenes o videos no muestran las miniaturas, aun cuando las aplicaciones para generarlas funcionan correctamente.

Este comportamiento generalmente está relacionado con el dominio de seguridad thumb_t, introducido para proteger el sistema ante posibles ataques mediante archivos maliciosos procesados por los thumbnailers.

En este artículo veremos:

Por qué ocurre el problema.
Cómo habilitar los thumbnailers de forma rápida.
Cómo revertir el cambio.
Cómo aplicar una solución más segura mediante una política puntual de SELinux.

¿Por qué SELinux bloquea los thumbnailers?

SELinux implementa un aislamiento adicional para los generadores de miniaturas, con el objetivo de evitar que procesos externos ejecuten código mientras el sistema está bloqueado o sin validación del usuario.

Cuando alguna operación del thumbnailer no está permitida por la política, se generan eventos de denegación (AVC denials), y como consecuencia:

No se generan miniaturas.
El gestor de archivos muestra solo iconos genéricos.
Algunos procesos quedan confinados en el dominio thumb_t.

Esto se observa en el log del sistema (journalctl -t setroubleshoot) con mensajes similares a:

avc: denied { connectto } for scontext=... tcontext=... tclass=unix_stream_socket

Solución rápida: colocar thumb_t en modo permisivo

Si el entorno de escritorio depende de las miniaturas para el flujo de trabajo, una solución inmediata consiste en poner el dominio thumb_t en modo permisivo:

$ sudo semanage permissive -a thumb_t

Con esto:

SELinux deja de bloquear las operaciones de los thumbnailers
Las miniaturas vuelven a generarse correctamente.
Se siguen registrando los eventos en los logs.

Es una solución funcional y simple, útil para equipos personales o entornos no críticos.

Cómo revertir el cambio (volver al modo enforcing)

Si deseas regresar al comportamiento seguro por defecto, ejecuta:

$ sudo semanage permissive -d thumb_t

Puedes validar el estado con:

$ sudo semanage permissive -l

Si thumb_t ya no aparece en la lista, volvió al modo enforcing.

Alternativa recomendada: Crear una política mínima permitida

En lugar de deshabilitar por completo el confinamiento del dominio, es posible generar una política puntual que permita únicamente las acciones necesarias para los thumbnailers.

Este enfoque es más seguro y apropiado para estaciones de trabajo corporativas, equipos compartidos y entornos productivos.

Reproducir el problema

Borra el caché de thumbnails:

$ rm -rf ~/.cache/thumbnails/*

Abre una carpeta con imágenes o videos.

2. Extraer los registros AVC recientes

$ sudo ausearch -m avc -ts recent

Si el comando anterior no arroja salida alguna, prueba con otra marca de tiempo como today en vez de recent.

3. Generar una política personalizada

$ sudo ausearch -m avc -ts recent | audit2allow -M thumb_fix
$ sudo semodule -i thumb_fix.pp
Ésta política:

Autoriza únicamente las operaciones legítimas detectadas.
Mantiene la protección original del dominio thumb_t.

Conclusión

El dominio thumb_t en SELinux mejora la seguridad del sistema, pero en algunos escenarios puede afectar la generación de miniaturas en el escritorio. Afortunadamente, existen alternativas como las que acabamos de ver que nos permiten mantener el usuo de miniaturas en los íconos sin desabilitar SELinux completamente y exponer nuestro sistema. La clave está en entender el comportamiento de SELinux y aplicar la opción que mejor equilibre usabilidad y seguridad dependiendo del contexto.

Introducción a Regular Expressions: El comando perl

2025-10-03T15:39:00.004-04:00

El comando perl es uno de los más poderosos en Linux para la manipulación y el procesamiento de texto. Gracias a su motor de expresiones regulares, perl ofrece más flexibilidad que herramientas como sed o awk, permitiendo realizar búsquedas, reemplazos y análisis muy complejos en archivos de texto.

A continuación, exploraremos cómo usar perl con regex para modificar y analizar nuestro texto.

Nuestra guía y referencia de estudio es éste cheatsheet (conocidos como chuleta o chivo, en español) y como texto objetivo usaremos el poema Hay Un País en el Mundo, del poeta nacional (dominicano) Pedro Mir (1913-2000).

El comando perl.

Perl es un lenguaje de programación diseñado por Larry Wall en 1987. Perl toma características del lenguaje C, del lenguaje interpretado bourne shell (sh), AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación.

Estructuralmente, Perl está basado en un estilo de bloques como los del C o AWK, y fue ampliamente adoptado por su destreza en el procesado de texto y no tener ninguna de las limitaciones de los otros lenguajes de script. (Wikipedia, 2025).

Sintaxis del comando perl:

$ perl -pe 's/regex/reemplazo' archivo

-p: procesa el archivo línea por línea y lo imprime.
-e: permite ejecutar directamente código en la línea de comandos.

Para cambiar todas las apariciones de "mundo" por "universo":

$ perl -pe 's/mundo/universo/g' hay-un-pais-en-el-mundo.txt

s/.../.../g: significa sustitución global en cada línea.

Eliminar todas las líneas que contengan "país":

$ perl -ne 'print unless /país/' hay-un-pais-en-el-mundo.txt

-n: procesa el archivo línea a línea, pero no imprime automáticamente.
print unless /país/: imprime todas las líneas excepto las que contienen “país”.

Transformar en mayúsculas todas las palabras con más de 8 caracteres:

$ perl -pe 's/\b\w{9,}\b/uc($&)/ge' hay-un-pais-en-el-mundo.txt

\b\w{9,}\b: coincide con palabras de 9 o más caracteres.
uc($&): convierte la coincidencia ($&) a mayúsculas.
e: evalúa el reemplazo como código Perl.

Imprimir únicamente las líneas que comiencen con vocal:

$ perl -ne 'print if /^[AEIOUaeiou]/' hay-un-pais-en-el-mundo.txt

^: indica inicio de línea.
[AEIOUaeiou]: coincide con vocales en mayúscula o minúscula.

Contar cuántes veces aparece la palabra "mundo":

$ perl -ne '$c+=()=/mundo/g; END{print "$c\n"}' hay-un-pais-en-el-mundo.txt

()=/mundo/g: cuenta todas las coincidencias de “mundo” en cada línea.
END{print ...}: imprime el total al final.

Agregar texto despues de cada línea que termina en "mundo":

$ perl -pe 's/(mundo)$/\1 - Reflejo de realidad/' hay-un-pais-en-el-mundo.txt

(mundo)$: busca la palabra “mundo” al final de línea.
\1: inserta la coincidencia original y añade el texto nuevo.

Opciones útiles de perl para regex

-p: procesa cada línea y la imprime automáticamente.
-n: procesa cada línea sin imprimir automáticamente (se usa con condiciones).
-i: edita el archivo en su lugar (como sed -i).
-e: ejecuta un script corto en línea.

El comando perl es una de las herramientas más potentes en la terminal para manipular texto con regex, superando en flexibilidad a sed y awk. Con ejemplos aplicados al poema Hay un País en el Mundo, vimos cómo perl puede reemplazar, eliminar, resaltar, contar y transformar texto con gran precisión.

Su verdadero poder radica en que combina expresiones regulares con la capacidad completa de un lenguaje de programación.

Puedes profundizar más sobre el comando awk al consultar su manual:

$ man perl

SMB3 UNIX extensions en Samba+ 4.22: Un paso histórico en la interoperabilidad

2025-06-23T16:18:00.002-04:00

Frankfurt University of Applied Sciences (Frankfurt UAS) se ha convertido en uno de los primeros entornos productivos en usar SMB3 UNIX Extensions con Samba, conectando clientes Linux a servidores Samba usando exclusivamente SMB3 en lugar de combinar NFS y SMB. Eso permite manejar correctamente enlaces simbólicos y permisos POSIX, como si fuera un sistema de archivos nativo, transparente y sin compromisos.

Antes, sistemas Linux no podían aplicar chmod, ln -s y otras operaciones tipo UNIX a través de SMB; ahora, gracias a estas extensiones, esas operaciones sí funcionan igual que en sistemas nativos POSIX.

Las extensiones SMB3 Unix ya se integraron en Samba 4.22, lanzado en abril de éste mismo año. SerNet (empresa detrás de SAMBA+) ya las incluyó en sus paquetes, mientras que la rama oficial "upstream" de Samba las incorporará en la versión 4.23 (a salir en otoño de 2025).

SerNet colaboró directamente con el equipo tecnológico de Frankfurt UAS, demostrando su rol activo en despliegues grandes y en el desarrollo de funciones avanzadas como ésta. Además, ofrecen soporte profesional, incluyendo desarrollo y paquetes SAMBA+ certificados para entornos empresariales.

¿Qué impacto tiene para ti como administrador Samba?

Un único protocolo dominante (SMB3) mejora la compatibilidad sin necesidad de NFS, simplificando la arquitectura.
Mejora en la seguridad con la salida de NFS del escenario.
Mejor soporte para clientes Linux trabajando con permisos y enlaces simbólicos, como si trabajasen en local.
Reducción de complejidad en entornos mixtos (interoperabilidad Windows/Linux).

Ésta implementación de Samba 4.22 con extensiones SMB3 UNIX, a parte de ser una mejora técnica, es una invitación a modernizar nuestras redes, reducir la complejidad y mejorar la interoperabilidad y la seguridad.

La experiencia de Frankfurt UAS demuestra que es una tecnología madura, lista para producción.

Continúa ampliando en los siguientes enlaces:

https://samba.plus/blog/detail/milestone-reached-smb3-unix-extensions-now-fully-integrated

https://samba.plus/blog/detail/sernet-team-rolls-out-samba-422-at-frankfurt-uas

https://wiki.samba.org/index.php/UNIX_Extensions

https://wiki.samba.org/index.php/SMB3-Linux

Introducción a Regular Expressions: El comando awk

2024-12-05T16:37:00.007-04:00

AWK es un lenguaje de programación diseñado para procesar datos basados en texto, ya sean ficheros o flujos de datos. El nombre AWK deriva de las iniciales de los apellidos de sus autores: Alfred Aho, Peter Weinberger, y Brian Kernighan. awk, cuando está escrito todo en minúsculas, hace referencia al programa de Unix o Plan 9 que interpreta programas escritos en el lenguaje de programación AWK (Wikipedia, 2024).

Continuando con ésta serie nos enfocaremos en éste comando. Nuestra guía y referencia de estudio es éste cheatsheet (conocidos como chuleta o chivo, en español) y como texto objetivo usaremos el poema Hay Un País en el Mundo, del poeta nacional (dominicano) Pedro Mir (1913-2000).

El comando awk.

En la mayoría de distribuciones GNU/Linux actuales, awk viene como la implementación del lenguaje de programación AWK del Proyecto GNU, llamada gawk. Sin embargo ésto no lo notamos porque el comando awk ubicado en /usr/bin/awk es un enlace simbólico a /usr/bin/gawk.

gawk se ajusta a la definición del lenguaje en el estándar POSIX 1003.1. y a su vez, se basa en la descripción de The AWK Programming Language, de Aho, Kernighan y Weinberger. gawk proporciona las características adicionales que se encuentran en la versión actual de awk de Brian Kernighan y numerosas extensiones específicas de GNU (Wikipedia, 2024).

Sintaxis del comando awk:

$ awk 'patrón {acción}' archivo

patrón: Define qué líneas o campos deben coincidir.
acción: Especifica qué hacer con las coincidencias.

Para encontrar todas las líneas que contienen la palabra "mundo":

$ awk '/mundo/' hay-un-pais-en-el-mundo.txt

"mundo" sería una RegEx muy simple.

Imprimir las líneas que comienzan con una vocal:

$ awk '/^[AEIOUaeiou]/d' hay-un-pais-en-el-mundo.txt

Aquí, ^ indica el inicio de la línea, y [AEIOUaeiou] es la RegEx que busca líneas que comiencen con cualquier vocal.

Para encontrar y mostrar todas las palabras de más de 8 caracteres en el poema:

$ awk '{for(i=1;i<=NF;i++) if(length($i)>8) print $i} hay-un-pais-en-el-mundo.txt

NF: Número de campos en la línea actual.
length($i): Calcula la longitud de cada palabra.

Para contar las líneas donde una palabra aparece consecutivamente:

$ awk '/\b(\w+)\s+\1\b/ {count++} END {print count}' hay-un-pais-en-el-mundo.txt

\b(\w+)\s+\1\b: Busca palabras que se repiten consecutivamente.
count++: Incrementa un contador para cada coincidencia.

Para reemplazar todas las apariciones de "país" por "nación":

$ awk '{gsub(/país/, "nación"); print}' hay-un-pais-en-el-mundo.txt

gsub(/país/, "nación"): Sustituye todas las ocurrencias de "país" por "nación".

Opciones útiles de awk para regex

-F Separador de campos: Define el delimitador de campos, útil para trabajar con archivos CSV.
BEGIN y END: Permite ejecutar acciones antes de leer el archivo o después de procesarlo.

Ejemplo con BEGIN y END

Mostrar un encabezado antes de procesar las líneas y un resumen al final:

$ awk 'BEGIN {print "Procesando poema...\n"} /mundo/ {print} END {print "\nFin del procesamiento"}' hay-un-pais-en-el-mundo.txt

Usar awk con regex abre un abanico de posibilidades para realizar manipulaciones avanzadas en archivos de texto. A través de estos ejemplos aplicados al poema, es fácil ver cómo las expresiones regulares permiten transformar y adaptar texto de forma detallada y eficiente.

Puedes profundizar más sobre el comando awk al consultar su manual:

$ man awk

5 Tips para crear un mejor prompt en ChatGPT (Prompt Engineering)

2024-11-29T20:05:00.003-04:00

Ya se cumplen dos años del lanzamiento por parte de OpenAI de ChatGPT, una aplicación de chatbot de inteligencia artificial que es un modelo de lenguaje especializado en el diálogo que se ajusta con técnicas de aprendizaje supervisadas y de refuerzo. En la actualidad está compuesto por los modelos GPT-4o mini (opción gratis) y GPT-4o (opción de pago), y sus previews GPT-o1 y GPT-o1 mini (Wikipedia, 2024).

Aquí te presento 5 Tips para crear los mejores prompts; fragmento de texto, una pregunta o una instrucción que se proporciona a un modelo de lenguaje, como un sistema de generación de texto basado en IA, para influir en la generación de un texto (Cebra, 2024). Es decir, lo que le preguntamos o decimos al chatbot de Inteligencia Artificial (ChatGPT) para que nos arroje respuestas. En comparación con los motores de búsqueda, sería el equivalente a la línea de texto que colocamos en ellos para realizar búsquedas de lo que nos interesa.

Manos a la obra...

1. Sé específico y claro

De forma clara plantea tu requerimiento con detalles relevantes.
Ej.: En vez de decirle, "Háblame de Linux," pregunta, "Dame un resumen de la historia de Linux desde sus orígenes, hitos y personajes y empresas importantes en su desarrollo."

2. Establece un tono y un formato

Sé específico con la forma, ya sea una explicación simple, un análsis formal, o un formato estructura como una lista, tabla o un esquema.
Ej.: "Dame un resumen de las distribuciones de Linux más importantes" o "Dame un diagrama de la familia de distribuciones Linux desde su origen hasta el año 2023, considerando la distro origen y sus derivadas."

3. Provee contexto y antecedentes

El contexto y los antecedentes le ayudan a refinar sus respuestas.
Ej.: "Explica el paradigma DevOps y el CI/CD a alguien con conocimientos muy básicos de computación."

4. Aplica juego de roles para lograr consejos específicos

Dile a ChatGPT que asuma un rol, papel o función.
Ej.: "Actúa como un experto en ciberseguridad y explícame cómo asegurar un endpoint Linux."

5. Iteraciones y refinamiento

Si la respuesta no es exactamente lo que estabas esperando, refina el prompt agregando detalles clarificantes.
Ej.: A una respuesta genérica al prompt del ejemplo 4, puedes seguir de ésta manera, "¿Puedes explicarme más detalladamente el impacto de los algoritmos de cifrado en la seguridad de los usuarios en Linux?"

Como sugerencia adicional, y ésto lo dice él mismo: (ChatGPT can make mistakes. Check important info.): CHATGPT PUEDE COMETER ERRORES. REVISA LA INFORMACIÓN IMPORTANTE...

¿Te han gustado éstos 5 Tips? ¿Te gustaría que los presente en un video-tutorial?

Déjame saber en los comentarios... 😁

Cómo actualizar Fedora 40 a Fedora 41 usando el comando dnf

2024-11-25T16:17:00.001-04:00

El método dnf permite gestionar actualizaciones offline con más flexibilidad. Esta herramienta prepara los paquetes necesarios mientras el sistema está en línea, y luego los aplica al reiniciar. A continuación, te explico cómo utilizarlo.

Fedora es una distribución GNU/Linux para propósitos generales. Es mantenida por una comunidad internacional de ingenieros, diseñadores y usuarios. Se caracteriza por su estabilidad, pero también por estar a la vanguardia en la adopción de software libre y de código abierto. Cuenta con el patrocinio principal de Red Hat (subsidiaria de IBM desde 2019), además de otras empresas de tecnologías de la información y fabricantes de equipos de cómputo como Dell o Lenovo (Wikipedia, 2024).

Requisitos previos

Tener conexión a Internet para preparar las actualizaciones.
Contar con espacio suficiente en disco para almacenar los paquetes descargados.
Usar una cuenta con permisos administrativos (sudoers grupo wheel).

Pasos para actualizar con dnf

1. Actualizar los repositorios y paquetes existentes: Ejecuta el siguiente comando para asegurarte de que los repositorios estén actualizados:

$ sudo dnf update -y --refresh

2. Instalar el plugin de actualización offline: En las versiones recientes de Fedora, este plugin suele estar instalado por defecto. Si no lo tienes, instálalo con:

$ sudo dnf install -y dnf-plugin-system-upgrade

3. Descargar los paquetes de la nueva versión, en éste caso sería la versión Fedora 41:

$ sudo dnf system-upgrade download --releasever=41 -y

Durante este paso:

Usa --allowerasing si encuentras conflictos de dependencias.
Incluye --best para instalar las versiones más recientes compatibles.

4. Iniciar la actualización: Una vez descargados los paquetes, reinicia el sistema y aplica las actualizaciones ejecutando el comando:

$ sudo dnf system-upgrade reboot

El equipo se reiniciará y actualizará automáticamente. Este proceso puede tardar varios minutos.

5. Verificar la actualización: Después de la actualización, comprueba que la misma haya sito exitosa ejecutando:

$ cat /etc/fedora-release

Este comando muestra la versión de Fedora instalada.

Ventajas de este método

Control detallado: Puedes resolver conflictos de dependencias antes de aplicar los cambios.
Eficiencia: Sólo necesitas conectividad durante la descarga de paquetes.
Flexibilidad: Permite personalizar opciones avanzadas con flags adicionales.

Consejos útiles

Depuración de errores: Si encuentras problemas durante la actualización, revisa los logs en /var/log/dnf.log.
Modo seguro: Considera usar una sesión tty (ej. Ctrl+Alt+F4) para evitar interrupciones gráficas durante la descarga.

Para más información sobre el uso de dnf y otras opciones, consulta la documentación oficial de Fedora.

https://docs.fedoraproject.org/en-US/quick-docs/upgrading-fedora-offline/

AutoSamba (bash script) Samba 4 AD DC en Fedora 40

2024-11-20T10:10:00.000-04:00

Prueba de un script bash que automatiza el proceso de creación de un Samba4 Active Directory Domain Controller en Fedora 40 Linux. El script actualiza el sistema, instala dependencias y otros paquetes necesarios para la infraestructura básica (DHCP, DNS, NTP, Kerberos, SSSD, etc.) y luego realiza el domain provision con los valores que le proporcionamos al inicio del mismo (FQDN y password del usuario administrator).

SerNet GmbH se une a la Fundación Linux

2024-11-19T13:44:00.000-04:00

La incorporación de SerNet GmbH como miembro de la Linux Foundation representa un hito importante tanto para la compañía como para la comunidad de software libre. SerNet, reconocida por sus contribuciones a los proyectos SAMBA+ y verinice, refuerza su compromiso con la innovación y la colaboración en el ecosistema open source.

¿Qué significa esto para SerNet?

Impulso al desarrollo de sus proyectos:
- SAMBA+: Una solución líder en gestión de identidad y acceso (IAM) y la mejor implementación de SMB para diversas distribuciones de Linux y IBM AIX.
- verinice: Un software clave para la gestión de riesgos, cumplimiento normativo (GRC), protección de datos y continuidad de negocio.
Colaboración global: La membresía en la Linux Foundation conecta a SerNet con una red de expertos, desarrolladores y organizaciones líderes en tecnología.
Oportunidades de innovación: Al participar en proyectos compartidos de la Fundación, SerNet podrá influir en estándares y tecnologías emergentes.

Contribuciones esperadas

SerNet planea aportar su experiencia en gestión de identidad, seguridad de la información y continuidad empresarial, fortaleciendo el ecosistema de software libre y promoviendo nuevas soluciones para desafíos tecnológicos.

Con esta nueva alianza, SerNet se posiciona como un actor clave en el avance del código abierto, reforzando su compromiso con la excelencia y la comunidad global.

Más información: https://www.sernet.de/en/

Introducción a Regular Expressions: El comando sed

2024-11-12T15:42:00.001-04:00

El comando sed es una herramienta poderosa en Linux para realizar modificaciones de texto automáticas. Con el uso de expresiones regulares (regex), sed permite realizar reemplazos y modificaciones complejas en archivos de texto, haciendo que el trabajo sea más eficiente y preciso.

En el primer post de ésta serie nos enfocamos en el comando grep, puedes verlo aquí. Nuestra guía y referencia de estudio es éste cheatsheet (conocidos como chuleta o chivo, en español) y como texto objetivo usaremos el poema Hay Un País en el Mundo, del poeta nacional (dominicano) Pedro Mir (1913-2000).

El comando sed.

Leemos en Wikipedia que sed (abreviatura de stream editor) "es un editor de flujo, una potente herramienta de tratamiento de texto para el sistema operativo Unix que acepta como entrada un archivo, lo lee y modifica línea a línea de acuerdo a un script, mostrando el resultado por salida estándar (normalmente en pantalla, a menos que se realice una redirección)."

sed soporta expresiones regulares (regex), que son patrones de búsqueda flexibles. Esto permite realizar reemplazos, extracciones, y otras operaciones complejas basadas en coincidencias de patrones. Las regex en sed son especialmente útiles para manejar textos grandes y realizar cambios precisos.

Sintaxis básica de sed con regex:

$ sed [opciones] 's/patrón/reemplazo/' archivo_de_texto

Para reemplazar cualquier palabra que termine en "ndo" con la palabra "SONANDO":

$ sed 's/\b\w*ndo\b/SONANDO/g' hay-un-pais-en-el-mundo.txt

\b: Define un límite de palabra.
\w*: Coincide con cualquier palabra.
g: Realiza el reemplazo en todas las ocurrencias en cada línea.

Eliminar líneas que comienzan con una vocal:

$ sed '/^[AEIOUaeiou]/d' hay-un-pais-en-el-mundo.txt

Extraer solo líneas con palabras de más de 7 letras:

$ sed -n '/\b\w\{7,\}\b/p' hay-un-pais-en-el-mundo.txt

\w\{7,\}: Coincide con palabras de al menos 7 caracteres.
p: Imprime solo las líneas coincidentes.

Puedes agregar una frase al final de cada línea que contenga la palabra "mundo", usando:

$ sed '/mundo$/ s/$/ - Reflejo de realidad/' hay-un-pais-en-el-mundo.txt

/mundo$/: Coincide con líneas que terminan en "mundo".
s/$/ - Reflejo de realidad/: Añade " - Reflejo de realidad" al final de la línea.

Si deseas resaltar palabras en las que una misma letra se repite consecutivamente, puedes usar el siguiente comando:

$ sed -r 's/\b(\w*([a-zA-Z])\2\w*)\b/*\1*/g' hay-un-pais-en-el-mundo.txt

(\w*([a-zA-Z])\2\w*): Coincide con palabras donde al menos una letra está repetida consecutivamente.
*: Resalta las palabras envolviéndolas entre asteriscos..

Opciones útiles de sed para regex

-r: Usa expresiones regulares extendidas, lo cual simplifica patrones regex.
-i: Edita el archivo en su lugar (normalmente las modificaciones solo son visibles en la salida estándar (stdout), guardando los cambios directamente.

Usar sed con regex abre un abanico de posibilidades para realizar manipulaciones avanzadas en archivos de texto. A través de estos ejemplos aplicados al poema, es fácil ver cómo las expresiones regulares permiten transformar y adaptar texto de forma detallada y eficiente.

Puedes profundizar más sobre el comando sed al consultar su manual:

$ man sed

Samba 4 Active Directory para el Flisol Bogotá 2024

2024-05-01T10:59:00.001-04:00

Samba 4.20 disponible para descargar

2024-03-31T21:26:00.000-04:00

Se encuentra disponible la primera versión estable de la serie 4.20 de Samba, éstas son las mejoras/novedades más relevantes que tendremos en la misma:

Soporte en Active Directory para Authentication Silos y Authentication Policies
Active Directory Claims
Servive Witness Protocol
Windows Search Protocol Client
Mit Kerberos 1.21 como mínimo es requerido
Mejoras en samaba-tool y sambacls

Ésta versión de Samba aún no se encuentra disponible en los repositorios de las distribuciones, pero puedes descargar su código fuente, compilar e instalar.

Indaga más detalles en el sitio oficial https://www.samba.org

¡Además les recuerdo que ya es en éste mes de abril el evento SambaXP 2024! Visiten el sitio oficial para que se anoten para nuestro webinar gratuito y obtengan su ticket de entrada al mismo vía Zoom https://www.sambaxp.org

Webinar Gratuito Controlador de Dominio y Active Directory Samba 4

2024-02-15T09:10:00.005-04:00

¡Inscríbete ya para nuestro webinar de abril!

Controlador de Dominio y Active Directory Samba 4 (Bind 9, NTP, DHCP, Kerberos y otros servicios Linux).

Conectaremos al menos un cliente Windows desde el cual vamos a administrar vía RSAT nuestro dominio.

sambaxp.org/#Registration

Webinar Controlador de Dominio Samba 4 para el SambaXP 2024

2023-10-11T10:47:00.001-04:00

¡Con mucha emoción les anticipo que el Webinar Samba 4 como Controlador de Dominio y Active Directory de fraterneo llegará al SambaXP 2024!

SambaXP es uno de los eventos de Software Libre más importantes en todo el mundo y es realizado en Alemania de manos de la empresa SerNet. Los talleres y charlas se llevan a cabo en el idioma inglés, sin embargo y con el interés de alcanzar las comunidades de habla hispana, los organizadores, en la persona de Johannes Loxen, me han otorgado el gran privilegio de presentar éste webinar en español.

El evento de 2024 está pautado para los días 17 y 18 de abril, con el "Webinar Controlador de Dominio y Active Directory Samba 4" como apertura el día 16 a partir de las 9:00 AST (UTC-4), todo a través de Zoom.

Para estar al tanto de los detalles del evento y cómo se accederá al mismo, visita su sitio oficial SambaXP.