En el mundo de la administración de sistemas y la ciberseguridad, conocer herramientas flexibles y potentes es clave. Una de esas herramientas es socat, una utilidad de red que puede parecer sencilla, pero que es extremadamente poderosa tanto para tareas legítimas como para pruebas de penetración. En este artículo, exploraremos cómo usar socat para redirección de puertos HTTP y también cómo puede ser utilizada en movimientos laterales dentro de una red.

¿Qué es socat?

socat (SOcket CAT) es una herramienta de línea de comandos que permite establecer conexiones bidireccionales entre dos flujos de datos. Estos flujos pueden ser sockets TCP, UDP, archivos, terminales, dispositivos serie, y más. Piensa en socat como el «netcat con esteroides».

Redirección de puertos HTTP con socat

Un caso de uso muy común es redirigir tráfico HTTP desde un puerto a otro. Por ejemplo, si tienes un servidor web corriendo en el puerto 8080 y quieres exponerlo en el puerto 80 sin cambiar la configuración del servicio, puedes hacer lo siguiente:

sudo socat TCP-LISTEN:80,fork TCP:127.0.0.1:8080

¿Qué hace este comando?

TCP-LISTEN:80 escucha en el puerto 80.

fork permite manejar múltiples conexiones simultáneamente.

TCP:127.0.0.1:8080 redirige todo el tráfico al puerto 8080 de localhost.

Con esto, cualquier petición a tu servidor en el puerto 80 será reenviada automáticamente al 8080. Es muy útil en entornos donde se quiere evitar modificar la configuración de un servicio que ya está corriendo.

Socat y los movimientos laterales en red

Además de ser útil para redirección de puertos a nivel local, socat también es ampliamente utilizado en movimientos laterales dentro de una red interna comprometida. Esta técnica es habitual en escenarios de post-explotación, cuando un atacante ya ha ganado acceso a una máquina intermedia en la red.

Escenario típico

Imagina que un atacante tiene acceso a una máquina que sí está expuesta a Internet (IP pública), y desde esa máquina puede acceder internamente a otra máquina que no tiene exposición directa externa, pero sí está conectada a la misma red interna.

Esta segunda máquina, por ejemplo, podría tener corriendo un servicio (como SSH, RDP, MySQL, etc.) en un puerto que solo es accesible desde la red interna.

El atacante, desde la máquina comprometida expuesta a Internet, puede usar socat para exponer ese puerto interno al exterior y acceder al servicio como si estuviera en su propia red.

Comando socat para exponer el puerto:

Ejemplo práctico:

Supón que la IP interna del segundo equipo es 192.168.1.20 y tiene SSH en el puerto 22. La máquina intermedia (la comprometida) tiene una IP pública, y quieres acceder a ese SSH desde tu equipo remoto a través de esa IP pública.

Ejecuta en la máquina intermedia:

Con esto:

• El puerto 2222 queda expuesto públicamente.

• Todo lo que llegue a puerto 2222 en la máquina intermedia se redirige al puerto 22 de la IP interna 192.168.1.20.

Desde fuera, el atacante solo necesita hacer:

Y estará accediendo a la máquina que antes solo era accesible desde la red interna.

¿Por qué esto es útil (o peligroso)?

• Permite al atacante pivotar entre máquinas.

• Expone servicios que normalmente estarían aislados de Internet.

• Es una técnica difícil de detectar si no se monitoriza adecuadamente el tráfico saliente/entrante.

La entrada Usando socat para redirección de puertos TCP se publicó primero en Aprende IT.

Cuando un dispositivo (como tu ordenador) quiere enviar un paquete de datos a otro, primero busca la dirección MAC de destino en su tabla ARP. Si no la encuentra, envía una solicitud ARP a toda la red preguntando: «¿Quién tiene esta dirección IP?». El dispositivo con esa IP responde con su dirección MAC, y así la tabla se actualiza.

La Configuración del Laboratorio del Ataque

El video ilustra este ataque en un entorno de laboratorio con una red 192.168.56.0/24 que incluye tres dispositivos clave:

• Un dispositivo con la IP 192.168.56.20 y la dirección MAC terminada en 80.
• Otro dispositivo con la IP 192.168.56.19 y la dirección MAC terminada en AB.
• El gateway (la puerta de enlace, o router) con la IP 192.168.56.1 y la dirección MAC terminada en 02.

El objetivo del ataque es que el dispositivo con la IP .20 se haga pasar por el dispositivo con la IP .19 para el resto de la red.

El Proceso del Ataque de ARP Spoofing

El ataque se ejecuta enviando paquetes ARP de «respuesta» falsos. El atacante no espera a que alguien pregunte, sino que proactivamente envía información incorrecta a la red.

Envenenamiento de la tabla ARP del gateway: El dispositivo atacante envía repetidamente paquetes ARP al gateway, afirmando que la dirección MAC para la IP 192.168.56.19 ahora es la misma que la del atacante (la que termina en 80).

Envenenamiento de la tabla ARP de la víctima: De manera similar, el atacante envía paquetes ARP al dispositivo víctima (el .19), afirmando que la dirección MAC del gateway (el .1) ahora es la del atacante (la que termina en 80).

Como resultado, las tablas ARP del gateway y de la víctima se «envenenan». El gateway piensa que la IP .19 está en la dirección MAC del atacante, y la víctima piensa que el gateway está en la dirección MAC del atacante.

Esto crea un escenario de «hombre en el medio» (Man-in-the-Middle). A partir de este momento, todo el tráfico que el dispositivo .19 intente enviar al gateway (es decir, a internet) será redirigido al atacante. De igual manera, todo el tráfico que el gateway intente enviar al dispositivo .19 también será redirigido al atacante.

El atacante puede interceptar este tráfico, registrarlo, modificarlo o incluso descartarlo, todo sin que la víctima o el gateway se den cuenta. Esta técnica es especialmente peligrosa en redes Wi-Fi públicas y permite a un atacante robar credenciales de inicio de sesión, datos personales y otra información sensible.

La entrada ¿Qué es el ARP Spoofing y cómo se convierte en un ataque «Man-in-the-Middle»? se publicó primero en Aprende IT.

El `rp_filter`, o Reverse Path Filtering, es una característica del kernel de Linux diseñada para validar la ruta de origen de los paquetes de red entrantes. Su función principal es asegurarse de que un paquete recibido en una interfaz de red podría haber sido enviado a través de esa misma interfaz si la respuesta tuviera que salir por ella. Esto se conoce como «unicast reverse path forwarding». Al verificar la validez de la ruta de origen, `rp_filter` se convierte en una defensa efectiva contra el IP spoofing.

Entender los diferentes modos de `rp_filter` es esencial para configurarlo adecuadamente:

• `0` (Desactivado): En este modo, no se realiza ninguna verificación de la ruta de origen. Es el ajuste menos seguro y debería evitarse en entornos de producción, ya que deja el sistema vulnerable a ataques de IP spoofing.
• `1` (Estricto): Este es el modo más seguro y recomendado. Realiza una verificación rigurosa de la ruta inversa. Si un paquete llega a una interfaz y la tabla de enrutamiento indica que la respuesta a ese paquete saldría por una interfaz diferente, el paquete se descarta. Esto es excelente para prevenir el spoofing, pero puede causar problemas en configuraciones de red complejas o asimétricas donde el tráfico de entrada y salida utiliza rutas distintas intencionadamente.
• `2` (Relajado): Este es el valor por defecto en muchas distribuciones. En este modo, la verificación es menos estricta. Un paquete es aceptado si la respuesta a ese paquete saldría por cualquier interfaz en el sistema. Es una buena opción para redes con enrutamiento asimétrico donde el modo estricto podría causar falsos positivos, aunque ofrece menos protección que el modo estricto.

—

Implementación y Consideraciones

Para verificar el estado actual de `rp_filter`, puedes usar el comando `sysctl -a | grep .rp_filter`. Para configurarlo en modo estricto, que es nuestra recomendación general para la mayoría de los servidores:

sysctl -w net.ipv4.conf.all.rp_filter=1

Es crucial recordar que los cambios con `sysctl -w` son temporales. Para persistir la configuración tras un reinicio, debes añadir la línea `net.ipv4.conf.all.rp_filter=1` (o el valor deseado) al archivo `/etc/sysctl.conf` y luego aplicar los cambios con `sysctl -p`.

En resumen, la correcta configuración de `rp_filter` es un paso fundamental en cualquier estrategia de ciberseguridad para un sistema Linux. Aunque no es una bala de plata contra todos los ataques DDoS, ya que un volumen de tráfico masivo puede saturar la red independientemente de si los paquetes son válidos o no, sí ayuda a descartar tráfico malicioso con IPs falsificadas a nivel del kernel, reduciendo la carga de procesamiento y haciendo el sistema más resiliente. Al comprender y aplicar este control, podemos fortalecer significativamente nuestras defensas contra ataques basados en IP spoofing.

La entrada Protegiendo tu Sistema Linux: La Importancia de `rp_filter` contra el IP Spoofing y los DDoS se publicó primero en Aprende IT.

En este artículo aprenderás cómo usar estas funciones integradas de Bash para verificar puertos TCP y UDP de forma rápida, simple y sin dependencias externas.

¿Qué es /dev/tcp/host/puerto y /dev/udp/host/puerto?

Bash tiene una característica oculta que permite usar redirecciones especiales para crear conexiones de red. Estas rutas (/dev/tcp/ y /dev/udp/) no existen en el sistema de archivos, pero Bash las interpreta internamente para abrir sockets.

echo > /dev/tcp/host/puerto

Esto intenta abrir una conexión TCP al host y puerto especificado.

Verificar un Puerto TCP desde Línea de Comandos

Para probar si un puerto está abierto, simplemente ejecuta:

echo > /dev/tcp/google.com/80 && echo "Puerto abierto" || echo "Puerto cerrado"

¿Qué hace esto?

Si la conexión se abre exitosamente, Bash continúa y muestra «Puerto abierto».

Si falla (por ejemplo, el puerto está cerrado o el host no responde), muestra «Puerto cerrado».

Con timeout

Para evitar que el comando quede colgado si el host no responde, puedes usar timeout:

timeout 3 bash -c "echo > /dev/tcp/google.com/80" && echo "Abierto" || echo "Cerrado o Timeout"

🛈 Requiere Bash con soporte de redirección /dev/tcp. No funciona en shells como sh o dash.

Verificar un Puerto UDP con /dev/udp

El uso para UDP es similar:

echo > /dev/udp/8.8.8.8/53 && echo "Enviado" || echo "Fallo"

Pero hay un detalle importante: UDP no garantiza entrega ni respuesta, por lo que este método no te dice si el puerto está abierto realmente.

¿Cómo recibir respuesta?

Puedes usar un descriptor de archivo para enviar y luego intentar leer:

exec 3<> /dev/udp/8.8.8.8/53
echo -ne '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00' >&3
read -t 2 -u 3 respuesta && echo "Respuesta: $respuesta" || echo "Sin respuesta"

Este ejemplo envía una consulta DNS vacía al puerto 53 y espera una respuesta.

Limitaciones del Método
Característica TCP UDP
Detectar si el puerto está abierto Fiable No confiable
Requiere herramientas externas No No
Recibe respuesta del servicio Sí (si el servicio responde) Solo si esperas una respuesta válida

¿Y si quiero algo más confiable para UDP?

Si necesitas verificar si un puerto UDP está realmente abierto y responde, mejor usa herramientas como:

nc -uzv       # netcat en modo UDP
nmap -sU -p   # escaneo UDP con Nmap

Usar /dev/tcp/ y /dev/udp/ es una excelente forma de comprobar puertos rápidamente sin depender de herramientas externas. Es especialmente útil en entornos minimalistas o scripts automatizados.

Resumen rápido:

✅ TCP: Funciona muy bien para comprobar puertos abiertos.

⚠️ UDP: Puede enviar datagramas, pero no garantiza saber si el puerto está abierto.

🧰 No necesitas instalar nada si tienes Bash.

¿Ya lo has probado en tus scripts? Déjanos tus dudas o comparte cómo lo usas tú.

La entrada Cómo Comprobar Puertos en Linux Usando /dev/tcp y /dev/udp (sin Telnet ni Netcat) se publicó primero en Aprende IT.

Paso 1: Instalar Google Authenticator

Lo primero que necesitas es instalar Google Authenticator en tu servidor. Este programa se integra fácilmente con PAM (Pluggable Authentication Modules) para añadir 2FA a la autenticación SSH.

Abre una terminal y actualiza los paquetes con:

sudo apt update

Luego, instala el paquete necesario:

sudo apt install libpam-google-authenticator

Ahora, es momento de configurar Google Authenticator para el usuario que va a conectarse mediante SSH. Si eres tú, simplemente ejecuta:

google-authenticator

Cuando ejecutes este comando, el sistema te mostrará un código QR en la pantalla. Abre la app de Google Authenticator (o cualquier otra app compatible con TOTP, como Authy o FreeOTP) y escanea el código. Así se vincularán la app y tu servidor. La aplicación generará códigos de seis dígitos que cambiarán cada cierto tiempo y que necesitarás para iniciar sesión.

Durante el proceso de configuración, el programa te hará una serie de preguntas (como si quieres permitir tokens de emergencia o establecer límites de tiempo). Te recomiendo que leas cada opción y elijas la configuración que mejor te convenga.

Paso 2: Configurar PAM para Google Authenticator

Ahora que tienes la app configurada, hay que decirle al sistema que utilice Google Authenticator como parte del proceso de autenticación.

Para ello, edita el archivo de configuración PAM de SSH:

sudo nano /etc/pam.d/sshd

Una vez dentro del archivo, añade esta línea al inicio:

auth required pam_google_authenticator.so

Guarda los cambios (con Ctrl + O y Enter, y luego Ctrl + X para salir del editor).

Paso 3: Configurar OpenSSH para soportar 2FA
El siguiente paso es modificar la configuración del servicio SSH para que soporte el 2FA. Para ello, edita el archivo de configuración de OpenSSH:

sudo nano /etc/ssh/sshd_config

Dentro del archivo, asegúrate de que estas líneas estén configuradas correctamente:

UsePAM yes
ChallengeResponseAuthentication yes

También debes definir el método de autenticación. Vamos a exigir que se use la clave pública junto con el código TOTP, así que añade o modifica esta línea:

AuthenticationMethods publickey,keyboard-interactive

Con esta configuración, SSH pedirá primero la autenticación por clave pública y después el código de Google Authenticator.

Paso 4: Reinicia el servicio SSH

Para aplicar todos los cambios, es necesario reiniciar el servicio SSH:

sudo systemctl restart sshd

Probando la autenticación en dos pasos

Ahora que todo está configurado, es momento de probar si funciona. Cierra la sesión actual y vuelve a conectarte al servidor mediante SSH. Si todo ha ido bien, el sistema te pedirá:

• Tu clave o password para conectar por SSH.
• El código de seis dígitos generado por Google Authenticator.

Si introduces ambos correctamente, tendrás acceso al servidor. ¡Así de fácil!

Consejos adicionales

Copia de seguridad del código QR: Cuando configures Google Authenticator, guarda una copia del código QR o las claves de emergencia. Si pierdes tu teléfono, te será muy útil.
Limita los intentos fallidos: Para mayor seguridad, puedes configurar fail2ban para bloquear direcciones IP después de varios intentos fallidos.
Deshabilita la autenticación por contraseña: Si solo permites la autenticación por clave pública y 2FA, tu servidor será mucho más seguro.

La entrada Cómo proteger tu servidor SSH con Google Authenticator y 2FA se publicó primero en Aprende IT.

1. Instalación de strace

La mayoría de las distribuciones de Linux vienen con strace preinstalado. Si no lo tienes, puedes instalarlo con:

# En Debian/Ubuntu
sudo apt-get install strace
​
# En CentOS/RHEL
sudo yum install strace

2. Ejecutar un programa con strace

Para iniciar un programa y rastrear sus llamadas al sistema, simplemente usa:

strace nombre_programa [argumentos]

Por ejemplo, para rastrear ls:

strace ls

Esto mostrará todas las llamadas al sistema que ls realiza desde que inicia hasta que termina.

3. Adjuntar strace a un proceso en ejecución

Si deseas rastrear un programa que ya está ejecutándose, puedes adjuntar strace a su proceso con el PID:

strace -p PID

Para encontrar el PID, puedes usar el comando ps o pgrep:

ps aux | grep nombre_programa
pgrep nombre_programa

4. Filtrar tipos específicos de llamadas al sistema

strace genera mucha salida, por lo que puede ser útil filtrar solo las llamadas que te interesan. Para ello, puedes especificar tipos de llamadas con el parámetro -e:

• Archivo: Para ver solo las llamadas relacionadas con archivos.

  strace -e trace=open,close,read,write nombre_programa

• Red: Para ver solo las llamadas relacionadas con la red.

  strace -e trace=network nombre_programa

• Errores: Para ver solo las llamadas que resultan en errores.

  strace -e trace=error nombre_programa

5. Identificar y localizar problemas comunes

a. Problemas de permisos

Si una llamada al sistema falla debido a permisos, verás un error EACCES. Esto puede significar que el usuario que ejecuta el programa no tiene acceso a algún archivo o directorio. Busca líneas como estas:

open("/ruta/al/archivo", O_RDONLY) = -1 EACCES (Permission denied)

b. Archivos no encontrados

Si un programa intenta abrir un archivo inexistente, verás un error ENOENT:

open("/ruta/al/archivo", O_RDONLY) = -1 ENOENT (No such file or directory)

Este tipo de error suele indicar rutas de archivo incorrectas o archivos faltantes.

c. Problemas de red

Para rastrear problemas de red, puedes filtrar por llamadas como connect, sendto, recvfrom, etc. Si ves un error ECONNREFUSED, podría indicar que el servidor al que intentas conectarte no está disponible o se está rechazando la conexión.

connect(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr("192.168.1.1")}, 16) = -1 ECONNREFUSED (Connection refused)

d. Fallos de memoria

Errores como ENOMEM pueden indicar que el sistema se está quedando sin memoria para ejecutar el programa.

mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -1 ENOMEM (Cannot allocate memory)

e. Errores de llamadas al sistema específicas

A veces, verás errores en llamadas específicas como fork o execve. Esto puede deberse a que el programa esté intentando ejecutar otro proceso que no encuentra o no tiene permisos. Para problemas con execve, revisa la existencia y los permisos de ejecución de los binarios.

execve("/bin/ls", ["ls"], [/* 23 vars */]) = -1 ENOENT (No such file or directory)

6. Registrar salida a un archivo

Si necesitas analizar la salida de strace después de la ejecución, redirígela a un archivo con -o:

strace -o salida_strace.log nombre_programa

Luego puedes analizar el archivo con herramientas como grep para buscar errores específicos.

7. Analizar el tiempo de cada llamada

Usa -T para mostrar el tiempo que cada llamada al sistema tarda en completarse, útil para detectar cuellos de botella:

strace -T nombre_programa

8. Resumen de estadísticas

Para obtener un resumen de estadísticas al final de la ejecución, usa -c. Esto muestra cuántas veces se llamó cada función, cuántos errores ocurrieron y el tiempo total.

strace -c nombre_programa

Ejemplo práctico: Diagnosticar problemas de un programa

Supongamos que tienes un programa llamado mi_programa que está experimentando problemas de rendimiento y fallos ocasionales. Podrías:

1. Ejecutar con strace:

   strace -o salida.log mi_programa

2. Revisar el archivo de salida en busca de errores comunes (ENOENT, EACCES, etc.) usando grep:

   grep "ENOENT" salida.log

3. Analizar las llamadas al sistema más lentas para detectar cuellos de botella:

   strace -T -o salida_tiempos.log mi_programa

4. Revisar las estadísticas de llamadas al sistema para ver si alguna se ejecuta inusualmente a menudo o consume demasiado tiempo:

   strace -c mi_programa

Resumen final

strace es una herramienta poderosa que permite ver la interacción de un programa con el sistema operativo en un nivel profundo. Utilizando filtros y analizando cuidadosamente la salida, puedes identificar problemas de permisos, archivos inexistentes, problemas de red y cuellos de botella de rendimiento.

La entrada Guía Básica para Utilizar strace se publicó primero en Aprende IT.

1. Actualización del Servidor

Primero, asegúrate de que el servidor Ubuntu esté actualizado.

Ejecutar en el servidor:

sudo apt update && sudo apt upgrade -y

2. Instalación de WireGuard

Instala WireGuard en el servidor.

Ejecutar en el servidor:

sudo apt install wireguard -y

3. Generación de Llaves del Servidor

Genera las claves privadas y públicas del servidor.

Ejecutar en el servidor:

wg genkey | tee /etc/wireguard/server_private.key | wg pubkey > /etc/wireguard/server_public.key

4. Configuración del Servidor WireGuard

Crea el archivo de configuración de WireGuard para el servidor.

Ejecutar en el servidor:

vim /etc/wireguard/wg0.conf

Agrega el siguiente contenido al archivo wg0.conf:

[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = 

# Habilitar NAT e IP Forwarding
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; echo 1 > /proc/sys/net/ipv4/ip_forward
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; echo 0 > /proc/sys/net/ipv4/ip_forward

# Guardar configuración entre reinicios (opcional)
SaveConfig = true

Reemplaza con la clave privada del servidor generada previamente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_private.key

5. Habilitación y Arranque de WireGuard

Activa y arranca el servicio WireGuard.

Ejecutar en el servidor:

sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

6. Verificación del Estado del Servidor WireGuard

Comprueba que WireGuard esté funcionando correctamente.

Ejecutar en el servidor:

sudo wg

Parte 2: Configuración de los Clientes WireGuard

1. Generación de Llaves del Cliente

Genera las claves privadas y públicas del cliente.

Ejecutar en el servidor:

wg genkey | tee /etc/wireguard/client1_private.key | wg pubkey > /etc/wireguard/client1_public.key

2. Añadir la Configuración del Cliente en el Servidor

Edita el archivo de configuración del servidor para añadir al cliente.

Ejecutar en el servidor:

sudo vim /etc/wireguard/wg0.conf

Agrega el siguiente bloque al final del archivo:

[Peer]
PublicKey = 
AllowedIPs = 10.0.0.2/32

Reemplaza con la clave pública del cliente que generaste:

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_public.key

3. Creación del Archivo de Configuración del Cliente

Crea el archivo de configuración del cliente.

Ejecutar en el servidor:

sudo nano /etc/wireguard/client1.conf

Agrega el siguiente contenido al archivo client1.conf:

[Interface]
PrivateKey = 
Address = 10.0.0.2/24
DNS = 1.1.1.1

[Peer]
PublicKey = 
Endpoint = :51820
AllowedIPs = 0.0.0.0/0

Reemplaza con la clave privada del cliente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_private.key

Reemplaza con la clave pública del servidor:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_public.key

Reemplaza con la dirección IP pública del servidor.

4. Generación de un Código QR para el Cliente

WireGuard permite que los clientes móviles configuren fácilmente la VPN mediante un código QR.

Instala la herramienta qrencode en el servidor:

sudo apt install qrencode -y

Genera el código QR para la configuración del cliente:

Ejecutar en el servidor:

qrencode -t ansiutf8 < /etc/wireguard/client1.conf

Este comando generará un código QR en la terminal que el cliente puede escanear con su aplicación WireGuard en Android o iOS.

5. Instalación y Configuración de WireGuard en el Cliente

Instala WireGuard en el dispositivo cliente:

Linux:

Ejecutar en el cliente:

sudo apt update && sudo apt install wireguard resolvconf iptables -y

Windows/Mac:

Descarga e instala la aplicación WireGuard desde el sitio oficial: https://www.wireguard.com/install/

Android/iOS:

Descarga la aplicación WireGuard desde Google Play Store o Apple App Store.

Configura WireGuard en el cliente:

Para Linux/Windows/Mac:

Importa el archivo de configuración client1.conf en la aplicación WireGuard.

Para dispositivos que no pueden usar un código QR, transfiere el archivo de configuración client1.conf al dispositivo cliente.

Una opción puede ser ejecutar desde el servidor el siguiente SCP si el servidor tiene acceso por SSH al cliente:

scp /etc/wireguard/client1.conf usuario@ip_cliente:/ruta/de/destino/

El fichero debe quedar en la ruta «/etc/wireguard/wg0.conf», si has podido hacer el SCP ya lo has completado, si no puedes  hacerlo, crea el fichero directamente en esa ruta y copia el contenido.

Android/iOS:

Abre la aplicación WireGuard y escanea el código QR generado anteriormente.
Conecta el Cliente a la VPN:

En la aplicación WireGuard del cliente, activa la conexión.

6. Verificación de la Conexión

Una vez conectado, prueba la conexión:

Ejecutar en el cliente:

ping 10.0.0.1

Esto debería devolver respuestas del servidor, indicando que la conexión VPN está funcionando correctamente.

Parte 3: Mantenimiento y Gestión

1. Añadir Más Clientes

Para añadir más clientes, simplemente repite los pasos de la Parte 2 para generar nuevas llaves, configurar nuevos pares en el servidor, y crear archivos de configuración para cada cliente.

2. Reiniciar el Servicio WireGuard

Si realizas cambios en la configuración del servidor, asegúrate de reiniciar el servicio:

Ejecutar en el servidor:

sudo systemctl restart wg-quick@wg0

3. Monitoreo del Estado de la VPN

Puedes verificar el estado de los pares conectados y sus estadísticas:

Ejecutar en el servidor:

sudo wg show

Vídeo

Esto te proporcionará información sobre los clientes conectados y el tráfico que están generando.

Siguiendo esta guía paso a paso, deberías poder configurar un servidor WireGuard en Ubuntu y conectar clientes de manera sencilla, incluyendo la opción de usar un código QR para la configuración en dispositivos móviles.

La entrada Cómo crear un servicio VPN con Wireguard se publicó primero en Aprende IT.

Tanto Dialog como Whiptail son herramientas que permiten crear interfaces gráficas simples y funcionales dentro de un terminal de texto. Estas herramientas son muy útiles para desarrollar menús, cuadros de diálogo, listas de selección, barras de progreso y mucho más. A lo largo de este artículo, te guiaremos a través de los conceptos básicos y ejemplos prácticos de ambas herramientas para que puedas utilizarlas en tus propios scripts.

¿Qué es Dialog?

Dialog es una herramienta de línea de comandos utilizada para generar cuadros de diálogo interactivos en terminales basados en texto. Es ampliamente utilizada en scripts de shell para crear menús interactivos, cuadros de confirmación, formularios, barras de progreso, entre otros.
Dialog permite a los usuarios interactuar con un script a través de una interfaz de usuario basada en texto, lo que es especialmente útil en entornos de servidores donde no se dispone de una interfaz gráfica completa.

Instalación de Dialog

Para instalar Dialog en una distribución basada en Debian o Ubuntu, simplemente ejecuta el siguiente comando:

sudo apt-get update
sudo apt-get install dialog

Para distribuciones basadas en Red Hat como CentOS o Fedora:

sudo yum install dialog

Ejemplos básicos de Dialog

Cuadro de mensaje simple

Este ejemplo muestra un cuadro de mensaje simple que solo tiene un botón «OK»:

#!/bin/bash
dialog --title "Mensaje" --msgbox "Hola, este es un cuadro de mensaje simple." 6 50
Explicación: En este script, --title define el título del cuadro de diálogo, --msgbox es el tipo de diálogo utilizado, "6 50" son las dimensiones del cuadro (6 líneas de alto y 50 caracteres de ancho).

Menú interactivo

El siguiente ejemplo crea un menú donde el usuario puede seleccionar una opción:

#!/bin/bash
opcion=$(dialog --title "Menú Principal" --menu "Selecciona una opción:" 15 50 4
1 "Opción 1"
2 "Opción 2"
3 "Opción 3"
4 "Salir" 3>&1 1>&2 2>&3)

clear

echo "Has seleccionado la opción: $opcion"

Explicación: El menú se muestra con opciones numeradas. 3>&1 1>&2 2>&3 se utiliza para redirigir la selección del usuario de vuelta a la salida estándar.

Lista de selección

En este ejemplo, el usuario puede seleccionar uno o más elementos de una lista:

#!/bin/bash
opciones=$(dialog --title "Selección de Paquetes" --checklist "Selecciona los paquetes que deseas instalar:" 15 50 5
1 "Apache" off
2 "MySQL" off
3 "PHP" off
4 "Python" off
5 "Java" off 3>&1 1>&2 2>&3)

clear

echo "Paquetes seleccionados: $opciones"

Explicación: –checklist crea una lista de elementos con casillas de verificación, donde off indica que la casilla está desmarcada por defecto.

Barra de progreso

Las barras de progreso son útiles para mostrar el avance de una tarea. Aquí tienes un ejemplo:

#!/bin/bash
{
for ((i = 0 ; i <= 100 ; i+=10)); do
sleep 1
echo $i
done
} | dialog --title "Progreso" --gauge "Instalando..." 10 70 0

Explicación: –gauge se utiliza para crear una barra de progreso. El bucle for simula el avance de una tarea, incrementando la barra en un 10% cada segundo.

¿Qué es Whiptail?

Whiptail es una alternativa ligera a Dialog que también permite crear interfaces interactivas basadas en texto en scripts de shell. Aunque Whiptail ofrece un conjunto similar de funciones, es especialmente útil en sistemas donde Dialog no está disponible o donde se prefiere una herramienta más liviana.
Instalación de Whiptail

Para instalar Whiptail en Debian, Ubuntu y sus derivados:

sudo apt-get update
sudo apt-get install whiptail

En distribuciones como CentOS, Red Hat y Fedora:

sudo yum install newt

Ejemplos básicos de Whiptail

Cuadro de mensaje simple

Al igual que con Dialog, puedes crear un cuadro de mensaje simple:

#!/bin/bash

whiptail --title "Mensaje" --msgbox "Este es un mensaje simple usando Whiptail." 8 45

Explicación: Este ejemplo es similar al de Dialog, pero utilizando Whiptail. Las dimensiones del cuadro son ligeramente diferentes.

Menú interactivo

Crear menús interactivos es sencillo con Whiptail:

#!/bin/bash

opcion=$(whiptail --title "Menú Principal" --menu "Elige una opción:" 15 50 4 \
"1" "Opción 1" \
"2" "Opción 2" \
"3" "Opción 3" \
"4" "Salir" 3>&1 1>&2 2>&3)

clear

echo "Has elegido la opción: $opcion"

Explicación: Este script funciona de manera similar al ejemplo de Dialog, permitiendo al usuario seleccionar una opción de un menú.

Lista de selección

Whiptail también permite crear listas de selección con casillas de verificación:

#!/bin/bash

opciones=$(whiptail --title "Selección de Paquetes" --checklist "Selecciona los paquetes que deseas instalar:" 15 50 5 \
"Apache" "" ON \
"MySQL" "" OFF \
"PHP" "" OFF \
"Python" "" OFF \
"Java" "" OFF 3>&1 1>&2 2>&3)

clear

echo "Paquetes seleccionados: $opciones"

Explicación: En este ejemplo, «ON» indica que la casilla de verificación está marcada por defecto, a diferencia del «off» de Dialog.

Barra de progreso

Finalmente, aquí tienes un ejemplo de una barra de progreso con Whiptail:

#!/bin/bash

{
    for ((i = 0 ; i <= 100 ; i+=10)); do
        sleep 1
        echo $i
    done
} | whiptail --gauge "Instalando..." 6 50 0

Explicación: Este ejemplo es muy similar al de Dialog, pero usando la sintaxis de Whiptail.

Tanto Dialog como Whiptail son herramientas poderosas y flexibles que permiten a los administradores de sistemas y desarrolladores crear interfaces de usuario interactivas dentro de un terminal. Aunque ambas herramientas son similares en funcionalidad, la elección entre una u otra puede depender de las necesidades específicas del sistema y las preferencias personales.

Dialog es más popular y ampliamente documentado, mientras que Whiptail es una alternativa más ligera que puede ser preferida en sistemas donde la minimización del uso de recursos es crucial.

En este artículo, hemos cubierto los conceptos básicos de Dialog y Whiptail con ejemplos prácticos que te permitirán comenzar a crear tus propios scripts interactivos. Ya sea que necesites un menú simple, un cuadro de mensaje o una barra de progreso, estas herramientas te proporcionarán las funcionalidades necesarias para mejorar la interacción de los usuarios con tus scripts.

Recuerda que la clave para dominar estas herramientas es la práctica. Prueba los ejemplos proporcionados, modifícalos para adaptarlos a tus necesidades, y continúa explorando las múltiples posibilidades que Dialog y Whiptail ofrecen para hacer que tus scripts sean más intuitivos y fáciles de usar.

Video

Script del video

A continuación pongo dos scripts de ejemplo de dos menús interactivos:

Dialog

#!/bin/bash

# Ejemplo de menú usando Dialog
dialog --menu "Seleccione una opción:" 15 50 4 \
1 "Ver información del sistema" \
2 "Mostrar uso del disco" \
3 "Configurar red" \
4 "Salir" 2>seleccion.txt

# Leer la opción seleccionada
opcion=$(cat seleccion.txt)

case $opcion in
    1)
        echo "Mostrando información del sistema..."
        # Aquí irían los comandos correspondientes
        ;;
    2)
        echo "Mostrando uso del disco..."
        # Aquí irían los comandos correspondientes
        ;;
    3)
        echo "Configurando la red..."
        # Aquí irían los comandos correspondientes
        ;;
    4)
        echo "Saliendo..."
        exit 0
        ;;
    *)
        echo "Opción no válida."
        ;;
esac

El resultado sería:

Whiptail

#!/bin/bash

# Ejemplo de menú usando Whiptail
opcion=$(whiptail --title "Menú Principal" --menu "Seleccione una opción:" 15 50 4 \
"1" "Ver información del sistema" \
"2" "Mostrar uso del disco" \
"3" "Configurar red" \
"4" "Salir" 3>&1 1>&2 2>&3)

# Verificar la opción seleccionada
case $opcion in
    1)
        echo "Mostrando información del sistema..."
        # Aquí irían los comandos correspondientes
        ;;
    2)
        echo "Mostrando uso del disco..."
        # Aquí irían los comandos correspondientes
        ;;
    3)
        echo "Configurando la red..."
        # Aquí irían los comandos correspondientes
        ;;
    4)
        echo "Saliendo..."
        exit 0
        ;;
    *)
        echo "Opción no válida."
        ;;
esac

Con whiptail el resultado sería este otro:

Como se puede ver, los resultados son muy parecidos.

Referencias y documentación

Para dialog y whiptail podemos encontrar una amplia documentación en https://invisible-island.net/dialog/dialog.html

La entrada Crear Scripts Interactivos en Linux: Usando Dialog o Whiptail se publicó primero en Aprende IT.

Instalación de RKHunter

Paso 1: Actualizar los Repositorios

Antes de instalar cualquier paquete nuevo, siempre es una buena práctica asegurarse de que los repositorios del sistema estén actualizados. Esto se puede hacer con el comando apt update.

apt update

Paso 2: Instalar RKHunter

Una vez que los repositorios estén actualizados, podemos proceder a instalar RKHunter junto con las herramientas básicas del sistema (coreutils).

apt install coreutils rkhunter -y

Paso 3: Descargar los Repositorios de la Base de Datos de RKHunter

Para que RKHunter funcione correctamente, necesitamos descargar los datos necesarios. Esto se puede hacer con el comando curl.

curl https://rkhunter.sourceforge.net/1.4/mirrors.dat > /var/lib/rkhunter/db/mirrors.dat

Configuración de RKHunter

Problema Común: No se Puede Actualizar

Si intentamos actualizar RKHunter inmediatamente después de la instalación, es probable que encontremos un error similar al siguiente:

root@host# rkhunter --update
[ Rootkit Hunter version 1.4.6 ]

Checking rkhunter data files...
  Checking file mirrors.dat                                  [ Skipped ]
  Checking file programs_bad.dat                             [ Update failed ]
  Checking file backdoorports.dat                            [ Update failed ]
  Checking file suspscan.dat                                 [ Update failed ]
  Checking file i18n versions                                [ Update failed ]

Please check the log file (/var/log/rkhunter.log)

Solución: Editar el Archivo de Configuración

Para solucionar este problema, necesitamos editar el archivo de configuración de RKHunter (/etc/rkhunter.conf). Usaremos vi o cualquier otro editor de texto que prefiramos.

vi /etc/rkhunter.conf

Dentro del archivo, modificamos los siguientes parámetros:

PKGMGR=DPKG
WEB_CMD=wget
UPDATE_MIRRORS=1
MIRRORS_MODE=0

Actualización de RKHunter

Después de realizar estos cambios, podemos intentar actualizar RKHunter nuevamente.

rkhunter --update

Si todo ha ido bien, deberíamos ver un mensaje indicando que los archivos se han actualizado correctamente.

Verificación de la Versión

Podemos verificar que estamos utilizando la versión más reciente de RKHunter con el siguiente comando:

rkhunter --versioncheck

Realizar un Escaneo del Sistema

Una vez que RKHunter esté configurado y actualizado, podemos proceder a realizar un escaneo completo del sistema.

rkhunter --check

Ejemplo de Salida de un Escaneo
Durante el escaneo, RKHunter verificará varios aspectos del sistema, incluyendo comandos del sistema, bibliotecas compartidas, y archivos sospechosos. Aquí hay un ejemplo de lo que podríamos ver:

[ Rootkit Hunter version 1.4.6 ]

Checking system commands...

  Performing 'strings' command checks
    Checking 'strings' command                               [ OK ]

  Performing 'shared libraries' checks
    Checking for preloading variables                        [ None found ]
    Checking for preloaded libraries                         [ None found ]
    Checking LD_LIBRARY_PATH variable                        [ Not found ]

  Performing file properties checks
    Checking for prerequisites                               [ OK ]
    /usr/sbin/adduser                                        [ OK ]
    /usr/sbin/chroot                                         [ OK ]
    /usr/sbin/cron                                           [ OK ]
    /usr/sbin/depmod                                         [ OK ]
    /usr/sbin/fsck                                           [ OK ]
    /usr/sbin/groupadd                                       [ OK ]
    /usr/sbin/groupdel                                       [ OK ]
    /usr/sbin/groupmod                                       [ OK ]
    /usr/sbin/grpck                                          [ OK ]
    /usr/sbin/ifconfig                                       [ OK ]
    /usr/sbin/init                                           [ OK ]
    /usr/sbin/insmod                                         [ OK ]
    /usr/sbin/ip                                             [ OK ]
    /usr/sbin/lsmod                                          [ OK ]
    /usr/sbin/modinfo                                        [ OK ]
    /usr/sbin/modprobe                                       [ OK ]
    /usr/sbin/nologin                                        [ OK ]
    /usr/sbin/pwck                                           [ OK ]
    /usr/sbin/rmmod                                          [ OK ]
    /usr/sbin/route                                          [ OK ]
    /usr/sbin/rsyslogd                                       [ OK ]
    /usr/sbin/runlevel                                       [ OK ]
    /usr/sbin/sshd                                           [ OK ]
    /usr/sbin/sulogin                                        [ OK ]
    /usr/sbin/sysctl                                         [ OK ]
    /usr/sbin/useradd                                        [ OK ]
    /usr/sbin/userdel                                        [ OK ]
    /usr/sbin/usermod                                        [ OK ]
    /usr/sbin/vipw                                           [ OK ]
    /usr/sbin/unhide                                         [ OK ]
    /usr/sbin/unhide-linux                                   [ OK ]
    /usr/sbin/unhide-posix                                   [ OK ]
    /usr/sbin/unhide-tcp                                     [ OK ]
    /usr/bin/awk                                             [ OK ]
    /usr/bin/basename                                        [ OK ]
    /usr/bin/bash                                            [ OK ]
    /usr/bin/cat                                             [ OK ]
    /usr/bin/chattr                                          [ OK ]
    /usr/bin/chmod                                           [ OK ]
    /usr/bin/chown                                           [ OK ]
    /usr/bin/cp                                              [ OK ]
    /usr/bin/curl                                            [ OK ]
    /usr/bin/cut                                             [ OK ]
    /usr/bin/date                                            [ OK ]
    /usr/bin/df                                              [ OK ]
    /usr/bin/diff                                            [ OK ]
    /usr/bin/dirname                                         [ OK ]
    /usr/bin/dmesg                                           [ OK ]
    /usr/bin/dpkg                                            [ OK ]
    /usr/bin/dpkg-query                                      [ OK ]
    /usr/bin/du                                              [ OK ]
    /usr/bin/echo                                            [ OK ]
    /usr/bin/ed                                              [ OK ]
    /usr/bin/egrep                                           [ OK ]
    /usr/bin/env                                             [ OK ]
    /usr/bin/fgrep                                           [ OK ]
    /usr/bin/file                                            [ OK ]
    /usr/bin/find                                            [ OK ]
    /usr/bin/fuser                                           [ OK ]
    /usr/bin/grep                                            [ OK ]
    /usr/bin/groups                                          [ OK ]
    /usr/bin/head                                            [ OK ]
    /usr/bin/id                                              [ OK ]
    /usr/bin/ip                                              [ OK ]
    /usr/bin/ipcs                                            [ OK ]
    /usr/bin/kill                                            [ OK ]
    /usr/bin/killall                                         [ OK ]
    /usr/bin/last                                            [ OK ]
    /usr/bin/lastlog                                         [ OK ]
    /usr/bin/ldd                                             [ OK ]
    /usr/bin/less                                            [ OK ]
    /usr/bin/logger                                          [ OK ]
    /usr/bin/login                                           [ OK ]
    /usr/bin/ls                                              [ OK ]
    /usr/bin/lsattr                                          [ OK ]
    /usr/bin/lsmod                                           [ OK ]
    /usr/bin/lsof                                            [ OK ]
    /usr/bin/mail                                            [ OK ]
    /usr/bin/md5sum                                          [ OK ]
    /usr/bin/mktemp                                          [ OK ]
    /usr/bin/more                                            [ OK ]
    /usr/bin/mount                                           [ OK ]
    /usr/bin/mv                                              [ OK ]
    /usr/bin/netstat                                         [ OK ]
    /usr/bin/newgrp                                          [ OK ]
    /usr/bin/passwd                                          [ OK ]
    /usr/bin/perl                                            [ OK ]
    /usr/bin/pgrep                                           [ OK ]
    /usr/bin/ping                                            [ OK ]
    /usr/bin/pkill                                           [ OK ]
    /usr/bin/ps                                              [ OK ]
    /usr/bin/pstree                                          [ OK ]
    /usr/bin/pwd                                             [ OK ]
    /usr/bin/readlink                                        [ OK ]
    /usr/bin/rkhunter                                        [ OK ]
    /usr/bin/runcon                                          [ OK ]
    /usr/bin/sed                                             [ OK ]
    /usr/bin/sh                                              [ OK ]
    /usr/bin/sha1sum                                         [ OK ]
    /usr/bin/sha224sum                                       [ OK ]
    /usr/bin/sha256sum                                       [ OK ]
    /usr/bin/sha384sum                                       [ OK ]
    /usr/bin/sha512sum                                       [ OK ]
    /usr/bin/size                                            [ OK ]
    /usr/bin/sort                                            [ OK ]
    /usr/bin/ssh                                             [ OK ]
    /usr/bin/stat                                            [ OK ]
    /usr/bin/strace                                          [ OK ]
    /usr/bin/strings                                         [ OK ]
    /usr/bin/su                                              [ OK ]
    /usr/bin/sudo                                            [ OK ]
    /usr/bin/tail                                            [ OK ]
    /usr/bin/telnet                                          [ OK ]
    /usr/bin/test                                            [ OK ]
    /usr/bin/top                                             [ OK ]
    /usr/bin/touch                                           [ OK ]
    /usr/bin/tr                                              [ OK ]
    /usr/bin/uname                                           [ OK ]
    /usr/bin/uniq                                            [ OK ]
    /usr/bin/users                                           [ OK ]
    /usr/bin/vmstat                                          [ OK ]
    /usr/bin/w                                               [ OK ]
    /usr/bin/watch                                           [ OK ]
    /usr/bin/wc                                              [ OK ]
    /usr/bin/wget                                            [ OK ]
    /usr/bin/whatis                                          [ OK ]
    /usr/bin/whereis                                         [ OK ]
    /usr/bin/which                                           [ OK ]
    /usr/bin/who                                             [ OK ]
    /usr/bin/whoami                                          [ OK ]
    /usr/bin/numfmt                                          [ OK ]
    /usr/bin/kmod                                            [ OK ]
    /usr/bin/systemd                                         [ OK ]
    /usr/bin/systemctl                                       [ OK ]
    /usr/bin/gawk                                            [ OK ]
    /usr/bin/bsd-mailx                                       [ OK ]
    /usr/bin/dash                                            [ OK ]
    /usr/bin/x86_64-linux-gnu-size                           [ OK ]
    /usr/bin/x86_64-linux-gnu-strings                        [ OK ]
    /usr/bin/telnet.netkit                                   [ OK ]
    /usr/bin/which.debianutils                               [ OK ]
    /usr/lib/systemd/systemd                                 [ OK ]

[Press  to continue]

...

[Press  to continue]

System checks summary
=====================

File properties checks...
    Files checked: 142
    Suspect files: 0

Rootkit checks...
    Rootkits checked : 498
    Possible rootkits: 0

Applications checks...
    All checks skipped

The system checks took: 4 minutes and 25 seconds

All results have been written to the log file: /var/log/rkhunter.log

One or more warnings have been found while checking the system.
Please check the log file (/var/log/rkhunter.log)

Automatización de Escaneos con Cron

Para asegurarnos de que nuestro sistema se mantenga seguro, es una buena idea programar escaneos automáticos. Podemos hacer esto editando el archivo /etc/crontab para añadir los trabajos cron necesarios. No olvidemos modificar el correo de destino para recibir las alertas.

vi /etc/crontab

Añadimos las siguientes líneas al archivo:

0 3 * * * root /usr/bin/rkhunter --update >> /var/log/rkhunter_update.log 2>&1
0 2 * * * root /usr/bin/rkhunter --cronjob --update --report-warnings-only | mail -s "RKHunter Daily Scan" tu-email@example.com

Con esto, hemos configurado un trabajo cron que actualizará RKHunter diariamente a las 3 AM y realizará un escaneo diario a las 2 AM, enviando un informe por correo electrónico solo si se encuentran advertencias.

La entrada Como Proteger tu Sistema Linux: Guía Definitiva para Instalar y Usar RKHunter se publicó primero en Aprende IT.

En la era digital, los chatbots de IA se están convirtiendo en herramientas indispensables para mejorar la experiencia del usuario en sitios web, aplicaciones y servicios. Si alguna vez has querido crear tu propio chatbot, estás en el lugar correcto. Hoy te voy a guiar paso a paso para que puedas configurar un chatbot utilizando Ollama y Open-WebUI. Vamos a profundizar en aspectos técnicos, así que prepárate para ensuciarte las manos con algunos comandos.

Instalación de Ollama sin Docker

Para empezar, vamos a instalar Ollama en tu sistema sin usar Docker. Este método es ideal si prefieres no lidiar con contenedores y deseas tener un control más directo sobre la instalación.

Descarga e instalación de Ollama

El primer paso es descargar e instalar Ollama utilizando un sencillo script. Abre tu terminal y ejecuta el siguiente comando:

curl https://ollama.ai/install.sh | sh

Este comando descargará e instalará Ollama en tu sistema. El script se encargará de todos los detalles, así que no necesitas preocuparte por las dependencias.

Iniciar el servicio de Ollama

Una vez que la instalación haya finalizado, es hora de iniciar el servicio de Ollama. Esto lo haremos con el siguiente comando:

systemctl start ollama

Este comando inicia el servicio de Ollama, permitiendo que esté listo para ejecutar los modelos de IA.

Ejecutar modelos de IA con Ollama

Con Ollama instalado y el servicio en funcionamiento, el siguiente paso es ejecutar los modelos de IA. Ollama soporta varios modelos, y en este ejemplo, usaremos llama2 y mistral. Para ejecutar llama2, utiliza el siguiente comando:

ollama run llama2

Para ejecutar mistral, simplemente cambia el nombre del modelo en el comando:

ollama run mistral

Con estos comandos, tu instalación de Ollama estará ejecutando modelos de IA, listos para interactuar y responder a las consultas que le hagas.

Instalación de Ollama con Docker

Ahora, vamos a ver cómo instalar y configurar Ollama utilizando Docker. Este método es útil si prefieres tener un entorno más aislado y fácil de gestionar.

Detener el servicio de Ollama

Antes de continuar con Docker, necesitamos detener el servicio de Ollama que iniciamos anteriormente. Hazlo con el siguiente comando:

systemctl stop ollama

Configuración de Ollama con Docker

Con el servicio detenido, procedemos a configurar Ollama en un contenedor Docker. Ejecuta el siguiente comando para crear y ejecutar el contenedor:

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Este comando hace lo siguiente:

• -d ejecuta el contenedor en segundo plano.
• -v ollama:/root/.ollama monta un volumen para persistir los datos de Ollama.
• -p 11434:11434 asigna el puerto 11434 del host al contenedor.
• –name ollama nombra el contenedor como «ollama».

Ejecutar modelos de IA en Docker

Con el contenedor en funcionamiento, podemos ejecutar los modelos de IA dentro del contenedor. Utiliza el siguiente comando para acceder al contenedor y ejecutar el modelo mistral:

docker exec -it ollama ollama run mistral

Ahora, tu instalación de Ollama dentro de Docker está lista para funcionar con modelos de IA.

Levantar la Interfaz Web con Open-WebUI

Para hacer que la interacción con tu chatbot de IA sea más accesible y amigable, vamos a configurar una interfaz web utilizando Open-WebUI. Esta interfaz te permitirá interactuar con tu chatbot de manera visual y sencilla.

Configuración de Open-WebUI

Primero, asegúrate de que Ollama esté configurado correctamente y que el contenedor esté en funcionamiento. Luego, ejecuta el siguiente comando para levantar la interfaz web:

docker run -d -p 3000:8080 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Este comando hace lo siguiente:

• -d ejecuta el contenedor en segundo plano.
• -p 3000:8080 asigna el puerto 3000 del host al puerto 8080 del contenedor.
• -v ollama:/root/.ollama monta el volumen de Ollama.
• -v open-webui:/app/backend/data monta un volumen para los datos de Open-WebUI.
• –name open-webui nombra el contenedor como «open-webui».
• –restart always asegura que el contenedor se reinicie automáticamente si se detiene.

Acceder a la Interfaz Web

Con Open-WebUI en funcionamiento, puedes acceder a la interfaz web abriendo tu navegador y dirigiéndote a http://DIRECCION-DE-TU-SERVIDOR:3000

Aquí podrás interactuar con tu chatbot de IA de manera visual, realizar pruebas y ajustes según tus necesidades.

Documentación de Ollama

Aquí encontrarás información detallada sobre los parámetros válidos y sus valores, lo que te permitirá ajustar los modelos de IA para obtener los mejores resultados.

Documentación de Open-WebUI

Esta guía te proporcionará toda la información necesaria para personalizar la interfaz web, añadir nuevas funcionalidades y solucionar posibles problemas.

Pruebas y Mantenimiento
Una vez que tu chatbot de IA esté en funcionamiento, es importante realizar pruebas regulares para asegurarte de que todo funcione correctamente. Interactúa con el chatbot, realiza ajustes según sea necesario y mantén el software actualizado para aprovechar las últimas mejoras y correcciones de seguridad.

Con esta guía, ahora tienes todo lo que necesitas para crear tu propio chatbot de IA utilizando Ollama y Open-WebUI. No dudes en experimentar y ajustar según tus necesidades. ¡Buena suerte en tu aventura de creación de chatbots!

La entrada Cómo crear tu Propio Chatbot de IA con Ollama y Open-WebUI se publicó primero en Aprende IT.