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.

Instalación de Herramientas Necesarias

Antes de sumergirnos en el mundo del cifrado con LUKS, es esencial asegurarse de tener las herramientas adecuadas instaladas en tu sistema. Por lo general, la mayoría de las distribuciones de Linux incluyen estas herramientas de cifrado de manera predeterminada, pero siempre es bueno verificarlo.

Puedes instalar las herramientas necesarias utilizando el gestor de paquetes de tu distribución. En distribuciones basadas en Debian, como Ubuntu, puedes ejecutar el siguiente comando en la terminal:

sudo apt install cryptsetup

Si estás utilizando una distribución basada en Red Hat, como Fedora o CentOS, puedes instalar las herramientas de cifrado con el siguiente comando:

sudo dnf install cryptsetup

Una vez que hayas instalado cryptsetup, estarás listo para comenzar a trabajar con LUKS.

Creación de un Volumen LUKS

El primer paso para cifrar una partición o disco en Linux es crear un volumen LUKS. Este volumen actuará como una capa de cifrado que protegerá los datos almacenados en la partición o disco.

Para crear un volumen LUKS, necesitarás especificar la partición o disco que deseas cifrar. Asegúrate de que la partición esté desmontada antes de proceder. Supongamos que queremos cifrar la partición /dev/sdb1. El siguiente comando creará un volumen LUKS en esta partición:

sudo cryptsetup luksFormat /dev/sdb1

Este comando iniciará el proceso de creación del volumen LUKS en la partición especificada. Serás solicitado a confirmar esta acción, ya que el proceso borrará todos los datos existentes en la partición. Después de confirmar, se te pedirá que ingreses una contraseña para desbloquear el volumen LUKS en el futuro. Asegúrate de elegir una contraseña segura y recuérdala bien, ya que la necesitarás cada vez que quieras acceder a los datos cifrados.

Una vez completado el proceso, tendrás un volumen LUKS creado en la partición especificada, listo para ser utilizado.

Apertura y Cierre del Volumen LUKS

Después de crear un volumen LUKS, el siguiente paso es abrirlo para poder acceder a los datos almacenados en él. Para abrir un volumen LUKS, necesitarás especificar la partición que contiene el volumen y asignarle un nombre.

sudo cryptsetup luksOpen /dev/sdb1 mi_particion_cifrada

En este comando, /dev/sdb1 es la partición que contiene el volumen LUKS, y mi_particion_cifrada es el nombre que le estamos asignando al volumen abierto. Una vez que ejecutas este comando, se te pedirá que ingreses la contraseña que especificaste durante la creación del volumen LUKS. Después de ingresar la contraseña correcta, el volumen se abrirá y estará listo para ser utilizado.

Para cerrar el volumen LUKS y bloquear el acceso a los datos cifrados, puedes utilizar el siguiente comando:

sudo cryptsetup luksClose mi_particion_cifrada

Este comando cerrará el volumen LUKS con el nombre especificado (mi_particion_cifrada en este caso), lo que impedirá el acceso a los datos almacenados en él hasta que vuelva a abrirse.

Creación de un Sistema de Archivos en un Volumen LUKS

Una vez que hayas abierto un volumen LUKS, puedes crear un sistema de archivos en él para comenzar a almacenar datos de forma segura. Puedes utilizar cualquier sistema de archivos compatible con Linux, como xfs, xfs o btrfs.

Supongamos que queremos crear un sistema de archivos xfs en el volumen LUKS abierto (mi_particion_cifrada). El siguiente comando creará un sistema de archivos xfs en el volumen:

sudo mkfs.xfs /dev/mapper/mi_particion_cifrada

Este comando formateará el volumen LUKS abierto con un sistema de archivos xfs, lo que te permitirá empezar a almacenar datos en él de manera segura.

Montaje y Desmontaje de un Volumen LUKS

Una vez que hayas creado un sistema de archivos en un volumen LUKS, puedes montarlo en el sistema de archivos para acceder a los datos almacenados en él. Para montar un volumen LUKS, puedes utilizar el siguiente comando:

sudo mount /dev/mapper/mi_particion_cifrada /mnt

En este comando, /dev/mapper/mi_particion_cifrada es la ruta al dispositivo de bloque que representa el volumen LUKS abierto, y /mnt es el punto de montaje donde se montará el sistema de archivos.

Después de montar el volumen LUKS, puedes acceder a los datos almacenados en él como lo harías con cualquier otro sistema de archivos montado en Linux. Cuando hayas terminado de trabajar con los datos, puedes desmontar el volumen LUKS utilizando el siguiente comando:

sudo umount /mnt

Este comando desmontará el sistema de archivos del volumen LUKS, lo que evitará que accedas a los datos almacenados en él hasta que vuelva a montarse.

Administración de Volumenes LUKS

LUKS proporciona varias herramientas para administrar volumenes, incluida la capacidad de cambiar la contraseña, agregar claves adicionales y realizar copias de seguridad de las cabeceras de los volumenes.

Para cambiar la contraseña de un volumen LUKS, puedes utilizar el siguiente comando:

sudo cryptsetup luksChangeKey /dev/sdb1

Este comando te pedirá la contraseña actual del volumen LUKS y luego te permitirá ingresar una nueva contraseña.

Si deseas agregar una clave adicional al volumen LUKS, puedes utilizar el siguiente comando:

sudo cryptsetup luksAddKey /dev/sdb1

Este comando te pedirá la contraseña actual del volumen LUKS y luego te permitirá ingresar una nueva clave adicional.

Para realizar una copia de seguridad de la cabecera de un volumen LUKS, puedes utilizar el siguiente comando:

sudo cryptsetup luksHeaderBackup /dev/sdb1 --header-backup-file backup_file

Este comando realizará una copia de seguridad de la cabecera del volumen LUKS en el archivo especificado, lo que te permitirá restaurarla en caso de que se dañe la cabecera del volumen.

Resumen de comandos para crear volumen cifrado con luks

sudo cryptsetup luksFormat /dev/DISCO
sudo cryptsetup luksOpen /dev/DISCO DISCO_DESCIFRADO
sudo mkfs.xfs /dev/mapper/DISCO_DESCIFRADO
sudo mount /dev/mapper/DISCO_DESCIFRADO /ruta_de_montaje

Integración con crypttab y fstab

Una vez que has cifrado una partición o disco utilizando LUKS en Linux, es posible que desees configurar la apertura automática del contenedor LUKS durante el arranque del sistema y montarlo en un punto específico del sistema de archivos. Esto se puede lograr utilizando los archivos de configuración crypttab y fstab.

Configuración de crypttab

El archivo crypttab se utiliza para configurar el mapeo automático de dispositivos cifrados durante el proceso de arranque del sistema. Puedes especificar los dispositivos cifrados y sus correspondientes claves de cifrado en este archivo.

Para configurar un dispositivo cifrado en crypttab, primero necesitas conocer el UUID (Identificador Único Universal) del contenedor LUKS. Puedes encontrar el UUID ejecutando el siguiente comando:

sudo cryptsetup luksUUID /dev/sdb1

Una vez que tengas el UUID del contenedor LUKS, puedes agregar una entrada en el archivo crypttab para configurar el mapeo automático. Por ejemplo, supongamos que el UUID del contenedor LUKS es 12345678-1234-1234-1234-123456789abc. Puedes agregar la siguiente entrada en el archivo crypttab:

mi_particion_cifrada UUID=12345678-1234-1234-1234-123456789abc none luks

También puede hacerse así en este caso sin usar el UUID:

mi_particion_cifrada /dev/sdb1 none luks

En esta entrada, mi_particion_cifrada es el nombre que le hemos dado al contenedor LUKS, y UUID=12345678-1234-1234-1234-123456789abc es el UUID del contenedor. La palabra none indica que no se utiliza una clave precompartida y luks especifica que el dispositivo está cifrado con LUKS.

Configuración de fstab

Una vez que has configurado el mapeo automático del dispositivo cifrado en crypttab, puedes configurar el montaje automático del sistema de archivos en fstab. El archivo fstab se utiliza para configurar el montaje automático de sistemas de archivos durante el arranque del sistema.

Para configurar el montaje automático de un sistema de archivos en fstab, primero necesitas conocer el punto de montaje y el tipo de sistema de archivos del contenedor LUKS. Supongamos que el punto de montaje es /mnt/mi_particion y el sistema de archivos es xfs. Puedes agregar una entrada en el archivo fstab de la siguiente manera:

/dev/mapper/mi_particion_cifrada /mnt/mi_particion xfs defaults 0 2

En esta entrada, /dev/mapper/mi_particion_cifrada es la ruta al dispositivo de bloque que representa el contenedor LUKS abierto, /mnt/mi_particion es el punto de montaje donde se montará el sistema de archivos, xfs es el tipo de sistema de archivos, defaults especifica las opciones de montaje por defecto, y 0 2 especifica las opciones de comprobación del sistema de archivos.

Recomendaciones con crypptab

En el caso de un servidor yo no tendría activo el crypttab, es decir, dejaria la configuración puesta pero comentada, al igual que con el fstab, Haría los montajes de forma manual tras un reinicio. Así evitamos tener que usar ficheros de clave y tener algunos problemas derivados

La entrada Cifrado de Particiones y Discos con LUKS en Linux se publicó primero en Aprende IT.

¿Qué es Wazuh y por qué deberías usarlo?

Wazuh es una plataforma de seguridad de código abierto que proporciona detección de intrusiones, monitorización de integridad, respuesta a incidentes y auditoría de cumplimiento. Su versatilidad lo hace ideal tanto para pequeñas empresas como para grandes corporaciones. Además, al ser de código abierto, Wazuh es completamente gratuito y permite modificaciones para adaptarse a cualquier necesidad específica.

Preparativos iniciales antes de la instalación

Antes de lanzarte a la instalación de Wazuh, es crucial que prepares tu sistema. Esto implica asegurarse de que el sistema operativo esté actualizado y configurar el entorno para que soporte la instalación de Wazuh mediante Docker. Aquí te explicamos cómo:

Primero, es necesario desactivar el firewall para evitar que interfiera en el proceso de instalación. Para esto, simplemente ejecuta en la terminal:

ufw disable

Este comando desactivará el firewall, asegurando que no bloqueará ninguna de las conexiones necesarias durante la instalación.

Después, debes asegurarte de que todos los paquetes del sistema están actualizados y que git está instalado, ya que lo necesitarás para clonar el repositorio de Wazuh. Ejecuta:

apt update && apt install git

Con estos comandos, tu sistema estará actualizado y listo para la siguiente fase.

Instalación de Docker

Wazuh en Docker simplifica la gestión de dependencias y asegura que la plataforma pueda ejecutarse de manera aislada y segura. Para instalar Docker, puedes usar el script proporcionado por Docker, que configura todo automáticamente:

curl -sSL https://get.docker.com/ | sh

Una vez instalado Docker, es esencial que asegures su ejecución automática al iniciar el sistema:

systemctl start docker
systemctl enable docker

Estos comandos iniciarán el servicio de Docker y lo configurarán para que se inicie automáticamente en cada arranque del sistema.

Docker compose

Si instalas docker como hemos indicado anteriormente, no es necesario que instales esta herramienta, pero si ya tienes docker y no soporta «docker compose», puedes instalar docker-compose así:

curl -L "https://github.com/docker/compose/releases/download/v2.12.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

Los siguiente comandos que tengan «docker compose» deben ejecutarse como docker-compose.

Configuración del entorno de Wazuh

Con Docker ya configurado, el siguiente paso es preparar el entorno específico para Wazuh. Dirígete al directorio óptimo para mantener organizados los archivos relacionados con la seguridad:

cd /opt

Ahora, es el momento de clonar la versión más reciente del repositorio de Wazuh para Docker:

git clone https://github.com/wazuh/wazuh-docker.git -b v4.7.3

Este comando descarga todos los archivos necesarios para ejecutar Wazuh en un contenedor Docker.

Generación de certificados y puesta en marcha de Wazuh

Antes de iniciar Wazuh, debes generar los certificados necesarios para el correcto funcionamiento de los componentes de Wazuh. Navega al directorio correcto y ejecuta el generador de certificados:

cd wazuh-docker/single-node/
docker compose -f generate-indexer-certs.yml run --rm generator

Con los certificados generados, ya estás listo para iniciar todos los servicios de Wazuh:

docker compose up -d

Este último comando levanta todos los contenedores necesarios para que Wazuh funcione adecuadamente en un modo de nodo único, ideal para entornos de prueba o pequeñas implementaciones.

Verificación de la instalación

Una vez completados todos los pasos anteriores, es importante verificar que todo esté funcionando como se espera. Puedes comprobar el estado de los contenedores de Docker para asegurarte de que todos los servicios de Wazuh están activos y ejecutándose. Además, accede a la interfaz web de Wazuh para comenzar a explorar las funcionalidades y configuraciones disponibles.

Personalización y monitorización

Con tu servidor de Wazuh ahora en funcionamiento, el siguiente paso es personalizar la configuración para adaptarla a tus necesidades específicas. Wazuh ofrece una gran variedad de opciones para configurar reglas, alertas y respuestas automáticas ante incidentes. Aprovecha la documentación disponible para explorar todas las posibilidades que te ofrece Wazuh.

Instalar y configurar tu propio servidor de Wazuh puede parecer una tarea compleja, pero siguiendo estos pasos podrás tener un sistema robusto de seguridad informática sin necesidad de grandes inversiones. No solo mejorará la seguridad de tu información, sino que también te proporcionará una herramienta poderosa para monitorizar y responder proactivamente a cualquier incidente.

Cambio de password de Wazuh

Detener el servicio usando Docker Compose:

docker compose down

Generar el hash de la nueva contraseña utilizando el contenedor de Wazuh:

Ejecuta el siguiente comando para iniciar el script de hash:

docker run --rm -ti wazuh/wazuh-indexer:4.6.0 bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/hash.sh

Ingresa la nueva contraseña cuando se te solicite y copia el hash generado.

Actualizar el archivo de usuarios internos con el hash de la nueva contraseña:

Abre el archivo con un editor de texto como vim:

vim config/wazuh_indexer/internal_users.yml

Pega el hash generado para el usuario admin.

Actualizar el archivo docker-compose.yml con la nueva contraseña:

Abre el archivo docker-compose.yml:

vim docker-compose.yml

Ingresa la nueva contraseña en las líneas 24 y 81 donde dice INDEXER_PASSWORD.

Levantar los servicios nuevamente con Docker Compose:

docker compose up -d

Esto reinicia la pila de servicios.

Acceder al contenedor y ejecutar el script de seguridad:

Accede al contenedor:

docker exec -it single-node-wazuh.indexer-1 bash

Define las variables y ejecuta el script de seguridad:

export INSTALLATION_DIR=/usr/share/wazuh-indexer
CACERT=$INSTALLATION_DIR/certs/root-ca.pem
KEY=$INSTALLATION_DIR/certs/admin-key.pem
CERT=$INSTALLATION_DIR/certs/admin.pem
export JAVA_HOME=/usr/share/wazuh-indexer/jdk
bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/securityadmin.sh -cd /usr/share/wazuh-indexer/opensearch-security/ -nhnv -cacert $CACERT -cert $CERT -key $KEY -p 9200 -icl

Sal del contenedor:

exit

Este proceso te permite actualizar la contraseña de administrador para Wazuh utilizando Docker, asegurándote de seguir correctamente todos los pasos para garantizar que los cambios sean efectivos.

La entrada Instala tu propio servidor de Wazuh en Ubuntu se publicó primero en Aprende IT.

En la era digital, mantener la privacidad y seguridad en línea es más crucial que nunca. Una de las maneras de proteger tu identidad y datos en la red es a través del uso de un servidor proxy SOCKS. Este tipo de proxy actúa como un intermediario entre tu dispositivo y el internet, ocultando tu dirección IP real y cifrando tu tráfico de internet. En este artículo, te guiaremos paso a paso en cómo configurar tu propio servidor proxy SOCKS en Ubuntu utilizando Dante, un servidor proxy versátil y de alto rendimiento.

Iniciando la instalación de Dante

Antes de sumergirnos en la configuración de Dante, es esencial preparar tu sistema y asegurarte de que está actualizado. Para ello, abre una terminal y ejecuta los siguientes comandos:

sudo apt update
sudo apt install dante-server

Estos comandos actualizarán la lista de paquetes de tu sistema y luego instalarán Dante, respectivamente.

Configuración del archivo danted.conf

Una vez instalado Dante, el siguiente paso es configurar el servidor proxy. Esto se hace editando el archivo de configuración danted.conf ubicado en /etc/danted/. Para ello, usa tu editor de texto preferido. Aquí, utilizaremos vim:

vim /etc/danted.conf

Dentro de este archivo, debes especificar detalles cruciales como las interfaces externa e interna, el método de autenticación y las reglas de acceso. A continuación, te mostramos una configuración ejemplo que puedes ajustar según tus necesidades:

logoutput: syslog
user.privileged: root
user.unprivileged: nobody

# La interfaz externa (puede ser tu dirección IP pública o el nombre de la interfaz)
external: eth0

# La interfaz interna (usualmente la dirección IP de tu servidor o loopback)
internal: 0.0.0.0 port=1080

# Método de autenticación
socksmethod: username

# Reglas de acceso
client pass {
    from: 0.0.0.0/0 to: 0.0.0.0/0
    log: connect disconnect error
}

# Quién puede utilizar este proxy
socks pass {
    from: 0.0.0.0/0 to: 0.0.0.0/0
    command: bind connect udpassociate
    log: connect disconnect error
    socksmethod: username
}

Esta configuración define un servidor SOCKS que escucha en todas las interfaces disponibles (0.0.0.0) en el puerto 1080. Utiliza autenticación por nombre de usuario y permite conexiones desde y hacia cualquier dirección.

Creación de un usuario para el proxy

Para que el proxy sea seguro y no esté abierto al público, es necesario crear un usuario específico para la conexión. Esto se logra con los siguientes comandos:

sudo useradd -r -s /bin/false nombre_usuario
sudo passwd nombre_usuario

Aquí, nombre_usuario es el nombre de usuario que deseas para la conexión al proxy. El comando useradd crea el usuario, y passwd te permite asignarle una contraseña.

Reiniciar y habilitar el servicio Dante

Con el usuario creado y el archivo de configuración ajustado, es momento de reiniciar el servicio Dante y asegurarse de que se ejecute al inicio del sistema:

sudo systemctl restart danted.service
sudo systemctl enable danted.service
sudo systemctl status danted.service

Además, es importante asegurarse de que el puerto 1080, que es donde escucha el proxy, esté permitido en el firewall:

sudo ufw allow 1080/tcp

Comprobación de la conexión

Finalmente, para verificar que todo está funcionando correctamente, puedes probar la conexión a través del proxy con el siguiente comando:

curl -v -x socks5://nombre_usuario:contraseña@tu_ip_del_servidor:1080 https://cualesmiip.es/

Recuerda reemplazar nombre_usuario, contraseña y tu_ip_del_servidor con tus datos específicos. Este comando utilizará tu servidor proxy para acceder a un sitio web que muestra tu dirección IP pública, verificando así que el tráfico realmente está siendo redirigido a través del proxy SOCKS.

Configurar un servidor proxy SOCKS con Dante puede parecer complejo al principio, pero siguiendo estos pasos, podrás tener un poderoso sistema

Puedes configurar un servidor proxy SOCKS5 utilizando OpenSSH en Ubuntu 22.04, lo cual es una alternativa más sencilla y directa en ciertos casos, especialmente para uso personal o en situaciones donde ya tienes un servidor SSH configurado. A continuación, te explico cómo hacerlo:

Crear un proxy Socks 5 con OpenSSH

A diferencia de dante, con el cual podemos crear un servicio de proxy con autenticación, con OpenSSH, podemos crear un tunel en un puerto que se puede utilizar de proxy socks sin autenticación por lo que lo conveniente es que se utilice solo para localhost dentro de un solo equipo (luego explicaremos mejor esto)

Instalación de OpenSSH Server

Si aún no tienes OpenSSH Server instalado en tu servidor que va a hacer de proxy, puedes instalarlo con el siguiente comando siempre y cuando sea una distribución basada en Debian / Ubuntu:

sudo apt update
sudo apt install openssh-server

Asegúrate de que el servicio está activo y se ejecuta correctamente con:

sudo systemctl status ssh

Configuración del Servidor SSH (Opcional)

Por defecto, OpenSSH escucha en el puerto 22. Puedes ajustar configuraciones adicionales editando el archivo /etc/ssh/sshd_config, como cambiar el puerto, restringir el acceso a ciertos usuarios, etc. Si realizas cambios, recuerda reiniciar el servicio SSH:

sudo systemctl restart ssh

Uso de SSH como un Proxy SOCKS5

Para configurar un túnel SSH que funcione como un proxy SOCKS5, utiliza el siguiente comando desde tu cliente (no en el servidor). Este comando establece un túnel SSH que escucha localmente en tu máquina en el puerto especificado (por ejemplo, 1080) y redirige el tráfico a través del servidor SSH:

ssh -D 1080 -C -q -N usuario@direccion_servidor

• -D 1080 especifica que SSH debe crear un proxy SOCKS5 en el puerto local 1080.
• -C comprime los datos antes de enviarlos.
• -q habilita el modo silencioso que minimiza los mensajes de log.
• -N indica que no se ejecuten comandos remotos, útil cuando solo quieres establecer el túnel.
• usuario es tu nombre de usuario en el servidor SSH.
• direccion_servidor es la dirección IP o dominio de tu servidor SSH.

En este punto es donde comentamos que con la opción -D debemos indicar unicamente el puerto ya que si exponemos el puerto a toda la red podemos estar permitiendo que otros equipos de la red utilicen este proxy sin autenticarse:

[ger@ger-pc ~]$ ssh -D 0.0.0.0:1081 root@192.168.54.100

Si lo comprobamos con el comando ss o con netstat podemos ver que está escuchando en todas las redes:

[ger@ger-pc ~]$ ss -putan|grep 1081
tcp LISTEN 0 128 0.0.0.0:1081 0.0.0.0:* users:(("ssh",pid=292405,fd=4)) 
[ger@ger-pc ~]$

Sin embargo, si conectamos especificando unicamente el puerto sin 0.0.0.0 o sin ninguna IP, lo hara solo en localhost:

[ger@ger-pc ~]$ ssh -D 1081 root@192.168.54.100

.......

[ger@ger-pc ~]$ ss -putan|grep 1081
tcp LISTEN 0 128 127.0.0.1:1081 0.0.0.0:* users:(("ssh",pid=292485,fd=5)) 
tcp LISTEN 0 128 [::1]:1081 [::]:* users:(("ssh",pid=292485,fd=4)) 
[ger@ger-pc ~]$

Conexión a través del Proxy SOCKS5:

Ahora puedes configurar tu navegador o aplicación para utilizar el proxy SOCKS5 en localhost y el puerto 1080. Cada aplicación tiene una manera diferente de configurar esto, así que necesitarás revisar las preferencias o la documentación de la aplicación.

Automatización de la Conexión (Opcional):
Si necesitas que el túnel se establezca automáticamente al inicio o sin interacción manual, puedes considerar usar una herramienta como autossh para mantener la conexión del túnel abierta y reconectar en caso de que se caiga.

Esta es una forma efectiva de establecer un proxy SOCKS5 rápido para un usuario o unos pocos usuarios, especialmente útil para eludir restricciones de red o asegurar tu tráfico en redes no confiables. La principal ventaja de este método es su simplicidad y que aprovecha la infraestructura SSH existente, sin necesidad de configurar software adicional en el servidor.

La entrada Crear Proxy SOCKS con Dante y con OpenSSH se publicó primero en Aprende IT.

¿Qué es un RAID?

Podemos definir un raid de discos como un grupo o matriz de discos independientes de hecho RAID es un acrónimo de Redundant Array of Indepent Disks. Los discos se unifican mediante software o hardware para redundar datos y/o utilizar toda la capacidad de cada disco en conjunto. Esto será más fácil de entender cuando definamos cada tipo de RAID más adelante.

Diferencia entre RAID por hardware y RAID por software

¿Qué es el RAID por software?

El RAID por software es como dice el nombre una aplicación que permite la creación de RAIDs a nivel lógico a partir de discos conectados a nuestro equipo. Este software crea un sistema de ficheros en el cual trabaja comportándose según el tipo de RAID configurado

¿Qué es el RAID por Hardware?

Un raid por hardware es un dispositivo físico que permite la creación de un RAID de discos.  Puede ser una tarjeta de expansión PCI o PCIE o bien esté integrada en la placa base, este hardware integra todo lo necesario para realizar un RAID sin utilizar el procesador ni la memoria RAM del sistema (como norma general), además puede integrar una caché. Esta caché puede agilizar las operaciones de lectura/escritura.

Cuales son sus principales diferencia y las ventajas de cada uno

•  El RAID por hardware requiere hardware el cual conlleva un coste
• Con el RAID por hardware en caso de fallar un disco, solo debemos insertar el disco nuevo y el normalmente se encarga de reconstruir el RAID sin ningún paso adicional (como norma general)
• El RAID por software evita el el punto de fallo de una única tarjeta RAID. Si falla esta tarjeta el RAID no funcionará.
• En los sistemas actuales ya no se nota tanto la diferencia de rendimiento respecto a los RAID por hardware ya que los procesadores son más potentes.
• El RAID por hardware no utiliza recursos del procesador de la máquina anfitrión.

Niveles RAID más usados

· RAID 0 (Data Striping, Striped Volume)

Este raid toma la capacidad de los discos añadidos y la suma. Por ejemplo si tenemos 2 discos de 1TB con este RAID conseguiremos un volumen de 2TB. Si los discos son de distintas capacidades, siempre toma la más baja para utilizarla, al igual que las RPM (revoluciones por minuto) del disco. Es decir, si tenemos un disco de 2TB a 7200RPM y otro de 1TB a 5400RPM tendremos un volumen de 2TB a 5400RPM, es decir, volvemos a tener un volumen de 2TB pero más lento. Por eso es importante que los discos sean similares.

Por otro lado en este tipo de RAIDs prima el rendimiento pero no la seguridad, no hay redundancia de datos por lo que si un disco se rompe se corromperá el volumen.

· RAID 1 (espejo)

Este RAID al igual que en el RAID anterior y en todos los RAID, los discos deben tener la misma capacidad para evitar desaprovechar discos. En esta modalidad de RAID se configura los dos discos en espejo, esto quiere decir que se replica todo el contenido del disco en otro disco por cada 2 discos 1 disco se dedica a redundar datos. Está recomendado para 2 discos. Este RAID tiene una ventaja añadida y son mayores velocidad de lectura multiusuario ya que pueden leerse datos de los dos discos. Sin embargo las escrituras se ralentizan ya que tienen que hacerse en ambos discos.

· RAID 5

Este RAID es el más popular debido a su bajo coste. Con 3 discos se dispone del 75% de la capacidad de los discos aproximadamente. Requiere solamente un mínimo de 3 discos y soporta la pérdida por completo de un disco. La información se sirve en bloques distribuidos por el total de los discos por lo que a mas discos mas rendimiento también influye el tamaño de los discos cuanto mas grandes sean mas tiempo tarda en reconstruirse el RAID en caso de fallo de un disco. Este RAID protege contra los fallos distribuyendo el cálculo de paridad por el conjunto de los discos y así protegiendo contra posibles errores de hardware.

El punto flaco de este tipo de RAID está en que si falla un disco, hasta reponerlo el volumen queda desprotegido contra algún fallo de otro disco. Aquí es donde entran los discos Spare. Un disco spare es un disco de reserva para que entre “a formar parte del juego” cuando uno de los discos falle, de esta forma el numero de discos que pueden fallar es dos (mientras que el RAID no esté en procedo de reconstrucción cuando falle el segundo disco) De esta forma evitamos el punto de fallo mencionado antes. Cuando se añade el disco spare este tipo de RAID también se conoce como RAID 5E. Hay dos tipos de spare: “Standby spare” y “hot spare”.

Si es un standby spare conlleva un proceso de reconstrucción durante la incorporación del disco spare sustituyendo al disco fallido sin embargo si es un hot spare este tiempo se minimiza.

· RAID 6

Digamos que es la evolución del RAID 5, necesita como mínimo 4 discos. Funciona como RAID 5 pero con doble banda de paridad que también se reparte por todos los discos. Este tipo de RAID soporta el fallo total de hasta dos discos hasta durante la reconstrucción del RAID. Es menos utilizado debido a que cuando se utilizan pocos discos se desaprovecha capacidad de dos discos ya que no llegan al máximo teórico, con 4 discos el RAID tendrá cerca de la mitad de la capacidad de los discos. Cuantos más discos se utilicen en el RAID más capacidad de cada disco es utilizada.

Al igual que en el RAID 5, en RAID 6 se pueden añadir discos spare (se suele llamar RAID 6E) para soportar un tercer disco fallido (este ultimo puede fallar sin corromper el volumen siempre y cuando el raid no se esté reconstruyendo ).

Niveles RAID anidados

Los niveles anidados de RAID es “RAID sobre RAID”. Es decir un RAID de un tipo montado sobre otro/s RAID de otro tipo. Así se pueden aprovechar las ventajas de cada RAID. Por ejemplo:

• RAID 0+1 : Es un espejo de RAIDs 0, es decir si tenemos 4 discos, se crean 2 raids 0 con cada pareja de discos y con los 2 volúmenes RAID creados se crea un raid 1. De esta forma añadimos redundancia al RAID 0.
• RAID 1+0: Es un RAID 0 de dos espejos (RAID 1). Se crean 2 RAID 1 con cada pareja de discos y con la pareja de RAID 1 creados, se crea un RAID 0.
• RAID 50 (5+0): Para este RAID son necesarios un mínimo de 6 discos. Se crean con cada trío de discos un RAID 5. Después con cada RAID creado se crea un raid 0 con los RAID 5 creados. Con 6 discos se alcanza un total de aproximadamente el 65% de la capacidad de los discos.

Tipos de RAID más habituales son:

• RAID 0: Para almacenamiento de datos no críticos de los cuales no importa su pérdida.
• RAID 1: Para sistemas operativos, por ejemplo en servidores. Se instala normalmente el sistema Operativo sobre un RAID 1.
• RAID 5: Almacenamiento en general por su bajo coste y buena fiabilidad.

Como montar en linux cada tipo de RAID con “mdadm”:

Un raid en linux es muy fácil de configurar utilizando los pasos que vamos a describir:

Paso1: Instalar mdadm: por defecto no suele estar instalado en Linux.

En debian y derivados:

apt-get install mdadm

En RedHat / CentOS y derivados:

yum install mdadm

Paso2: Hay que llenar de ceros los discos que se van a incluir en el RAID para evitar problemas con sistemas de ficheros existentes:

root@localhost:~# mdadm --zero-superblock /dev/hdb /dev/hdc

(Y tantos otros discos a utilizar) o con DD:

Paso 3: Lo siguiente sería crear el RAID, básicamente sería con:

mdadm -C /dev/NOMBRERAID --level=raid[NUMERO] --raid-devices=NUMERO_DE_DISCOS /dev/DISCO1 /dev/DISCO2

• RAID 0: Se seleccionan un mínimo de dos discos (como ejemplo vdc y vdd):

mdadm -C /dev/md0 --level=raid0 --raid-devices=2 /dev/vdc /dev/vdd

• RAID 1: EN el caso de RAID 1 lo mejor es seleccionar un máximo de 2 discos / volúmenes (ponemos como ejemplo igualmente vdc y vdd):

mdadm -C /dev/md0 --level=raid1 --raid-devices=2 /dev/vdc /dev/vdd

• RAID 5: Como mínimo tres discos:

mdadm -C /dev/md0 --level=raid5 --raid-devices=3 /dev/vdb /dev/vdc /dev/vdd

Si queremos un disco spare (tenemos que añadir todos los discos incluso el spare al RAID desde el principio):

mdadm -C /dev/md0 --level=raid5 --raid-devices=3 --spare-devices=1 /dev/vdb /dev/vdc /dev/vdd /dev/vde

• RAID 6: Como mínimo 4 discos

mdadm -C /dev/md0 --level=raid5 --raid-devices=4 /dev/vdb /dev/vdc /dev/vdd /dev/vde

Y con spares:

mdadm -C /dev/md0 --level=raid5 --raid-devices=4 --spare-devices=1 /dev/vdb /dev/vdc /dev/vdd /dev/vde /dev/vdf

En caso de fallar un disco de un RAID solo debemos extraerlo e insertar el nuevo disco y cuando introduzcamos el nuevo disco  (mirando el log del sistema de /var/log/messages) ejecutamos:

mdadm --add /dev/RAID /dev/NUEVO_DISCO

En caso de querer parar un RAID:

mdadm --stop /dev/md0 && mdadm --remove /dev/md0

Y para consultar el estado:

cat /proc/mdstat

Y esto ha sido todo sobre como crear un RAID por software en linux con mdadm.

Si te ha gustado el artículo deja tu comentario y/o comparte en tus redes sociales.

¡Nos vemos!

La entrada Como crear un RAID por software en linux con mdadm se publicó primero en Aprende IT.

Preparación del entorno

Antes de sumergirnos en la compilación de Python, es esencial preparar tu sistema Ubuntu 20.04 para asegurarnos de que el proceso se ejecute sin contratiempos. Esto incluye la actualización de los paquetes del sistema y la instalación de dependencias necesarias para la compilación de Python.

Para empezar, abre una terminal y ejecuta el siguiente comando para actualizar el índice de paquetes de tu sistema:

sudo apt update

Una vez actualizado el índice de paquetes, es momento de instalar algunas dependencias críticas que Python requiere para su compilación y ejecución. Ejecuta el siguiente comando para instalar estos paquetes:

sudo apt install -y gcc libssl-dev libbz2-dev libffi-dev zlib1g-dev make

Descarga y preparación del código fuente de Python

Con el entorno preparado, el siguiente paso es obtener el código fuente de Python 3.10.13, que es la versión que compilaremos. Para ello, utilizaremos wget, una herramienta que permite descargar archivos desde la web directamente a nuestra terminal. Antes de descargar el código fuente, asegúrate de eliminar cualquier archivo previo con el mismo nombre para evitar conflictos:

rm -f Python-3.10.13.tgz

Ahora, procede a descargar el archivo comprimido del código fuente de Python 3.10.13 con el siguiente comando:

wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tgz

Con el archivo descargado, el próximo paso es extraer su contenido. Utiliza el comando tar para descomprimir el archivo:

tar xzf Python-3.10.13.tgz

Después de extraer el archivo, cambia al directorio que contiene el código fuente:

cd Python-3.10.13

Compilación del código fuente

Antes de proceder con la compilación propiamente dicha, es una buena práctica limpiar cualquier compilación previa que pudiera estar presente en el directorio. Esto se hace con el comando make clean:

make clean

El siguiente paso es configurar el proceso de compilación. Python ofrece muchas opciones de configuración, pero nos centraremos en una configuración optimizada que incluye pip y configuraciones de ruta para las bibliotecas compartidas. Ejecuta el siguiente comando para configurar el entorno de compilación:

./configure --enable-optimizations --with-ensurepip=install --prefix=/usr/local --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"

Una vez configurado, procede a compilar Python utilizando make. Para aprovechar al máximo los recursos de tu sistema y agilizar el proceso de compilación, puedes especificar el número de trabajos que make debería ejecutar simultáneamente. Esto depende del número de núcleos de tu procesador. Suponiendo que tienes un procesador de 4 núcleos, puedes usar make -j 4 para compilar más rápido. Sin embargo, en esta guía, utilizaremos make altinstall para instalar Python sin sobrescribir la versión predeterminada del sistema:

make altinstall

Instalación de pip y virtualenv

Tras compilar e instalar Python, el siguiente paso es asegurarse de que pip, el administrador de paquetes de Python, esté actualizado y funcionando correctamente con nuestra nueva instalación de Python. A continuación, instalaremos virtualenv, una herramienta para crear entornos virtuales aislados, lo cual es esencial para la gestión de dependencias en proyectos Python.

Primero, descarga el script de instalación de pip:

wget https://bootstrap.pypa.io/get-pip.py

Ejecuta el script para instalar pip para Python 3.10:

python3.10 get-pip.py

Con pip ya instalado, procede a instalar virtualenv:

pip3.10 install virtualenv

Para evitar conflictos con otras versiones de Python, renombraremos los binarios de pip y virtualenv:

mv /usr/local/bin/pip /usr/local/bin/pip.new
mv /usr/local/bin/virtualenv /usr/local/bin/virtualenv-3.10

Uso de contenedores como alternativa a la compilación

Compilar Python desde el código fuente te proporciona control total sobre la instalación y configuración, permitiéndote optimizar el rendimiento y la seguridad. Sin embargo, este proceso puede ser tedioso y consumir tiempo. Como alternativa, puedes utilizar contenedores Docker para trabajar con diferentes versiones de Python de manera aislada y eficiente, sin la necesidad de compilar cada versión manualmente.

Docker simplifica la creación y gestión de entornos aislados para tus aplicaciones, conocidos como contenedores. Para iniciar un contenedor con Python 3.10.13, simplemente ejecuta el siguiente comando:

docker run -it --name python3 python:3.10.13-slim-bullseye

Este comando descarga la imagen oficial de Python 3.10.13 (basada en Debian Bullseye slim) y la ejecuta en un contenedor, proporcionándote un entorno Python aislado y listo para usar en cuestión de segundos.

Resumen de comandos

Con el fin de tenerlo todo agrupado en la secuencia correcta, este es el grupo de comandos que hemos ejecutado:

sudo apt update
sudo apt install -y gcc libssl-dev libbz2-dev libffi-dev zlib1g-dev make
rm -f Python-3.10.13.tgz
wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tgz
rm -f Python-3.10.13.tgz.*
tar xzf Python-3.10.13.tgz
cd Python-3.10.13
make clean
./configure --enable-optimizations --with-ensurepip=install --prefix=/usr/local --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"
make altinstall
wget https://bootstrap.pypa.io/get-pip.py
python3.10 get-pip.py
pip3.10 install virtualenv
mv /usr/local/bin/pip /usr/local/bin/pip.new
mv /usr/local/bin/virtualenv /usr/local/bin/virtualenv-3.10

La entrada Cómo compilar Python 3.10 en Ubuntu 20.04 se publicó primero en Aprende IT.