En este artículo vamos a ver cuáles son los permisos recomendados en Linux para archivos y directorios. Los permisos son una forma fundamental de controlar quién puede acceder, modificar o ejecutar los recursos del sistema. Comprender cómo funcionan es clave para mantener la seguridad y el buen funcionamiento de tu sistema.

¿Qué son los permisos en Linux?

En Linux, cada archivo o directorio tiene tres tipos de permisos:

• Lectura (r): permite ver el contenido.
• Escritura (w): permite modificar el contenido.
• Ejecución (x): permite ejecutar archivos o acceder a directorios.

Estos permisos se aplican a tres categorías de usuarios:

• Propietario (u): el usuario que creó el archivo o directorio.
• Grupo (g): usuarios del mismo grupo que el propietario.
• Otros (o): el resto de usuarios del sistema.

Cómo ver y cambiar permisos

Para visualizar los permisos de un archivo, puedes usar el comando:

ls -l

Por ejemplo:

-rw-r--r-- 1 usuario grupo 100 Mar 22 09:45 ejemplo.txt

Esto significa que:

• El propietario puede leer y escribir.
• El grupo y otros usuarios solo pueden leer.
• El primer carácter (-) indica que es un archivo regular.

Para modificar los permisos se usa el comando chmod, con dos notaciones:

• Numérica: usa valores del 0 al 7. Por ejemplo, chmod 644 archivo.txt otorga lectura y escritura al propietario, y solo lectura al grupo y a otros.
• Simbólica: usa letras. Por ejemplo, chmod u+x script.sh añade permiso de ejecución al propietario.

Permisos recomendados según el uso

Dependiendo del tipo de archivo o directorio, es recomendable usar los siguientes permisos:

• Directorios: deben tener al menos permiso de ejecución (--x) para poder acceder a su contenido.
• Archivos ejecutables: necesitan permiso de ejecución (+x).
• Archivos sensibles: deben tener los permisos más restrictivos posibles, como 600.
• Archivos compartidos: al menos deben tener permiso de lectura para el grupo o para otros.

Ejemplo práctico

drwxr-xr-x 2 usuario grupo 4096 Mar 22 09:50 bin 
-rwxr-xr-x 1 usuario grupo 50 Mar 22 09:49 hola.sh 
-rw------- 1 usuario usuario 10 Mar 22 09:48 clave.txt 
-rw-r--r-- 1 usuario grupo 20 Mar 22 09:47 nota.txt

En este caso:

• bin/ es un directorio accesible por todos.
• hola.sh es un script que todos pueden ejecutar.
• clave.txt es un archivo privado, solo accesible por el propietario.
• nota.txt es un archivo de lectura pública.

Conclusión

Entender los permisos en Linux es esencial para administrar bien tu sistema. Configurar correctamente los permisos te ayuda a proteger tus datos, evitar errores y mantener el control sobre los recursos del sistema.

¿Ya aplicas estas prácticas en tu sistema? ¿Te ha surgido alguna duda? ¡Te leo en los comentarios!

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Permisos recomendados para archivos y directorios en Linux se publicó primero en Linux Básico.

Si estás aprendiendo Linux y quieres ampliar el almacenamiento de tu sistema, añadir un nuevo disco duro es una excelente forma de practicar y mejorar tus habilidades. En esta guía vamos a ver cómo añadir un nuevo disco a un sistema Linux, paso a paso, de forma sencilla y segura.

1. Detectar el nuevo disco

Lo primero es conectar físicamente el disco duro (SATA, NVMe o USB) y arrancar el sistema. Una vez dentro, podemos verificar si el sistema lo detecta con el siguiente comando:

lsblk

También puedes usar:

sudo fdisk -l

Deberías ver un nuevo dispositivo como /dev/sdb (o /dev/nvme1n1 si es un disco NVMe).

2. Crear una nueva tabla de particiones

Usamos fdisk para discos /dev/sdX o gdisk si prefieres GPT:

sudo fdisk /dev/sdb

Dentro de fdisk, sigue estos pasos:

• Pulsa g para crear una tabla de particiones GPT (o o para MBR si lo prefieres)
• Pulsa n para crear una nueva partición
• Pulsa w para guardar y salir

3. Formatear la nueva partición

Una vez creada la partición, toca formatearla. Si es la partición /dev/sdb1, puedes usar:

sudo mkfs.ext4 /dev/sdb1

También puedes usar xfs o btrfs según tus preferencias.

4. Crear un punto de montaje

Escoge un lugar para montar el disco, por ejemplo:

sudo mkdir /mnt/disco_nuevo

5. Montar el disco

Ahora montamos la partición:

sudo mount /dev/sdb1 /mnt/disco_nuevo

Si todo ha ido bien, ya puedes usar el disco. Verifícalo con:

df -h

6. Montaje permanente (opcional)

Para que el disco se monte automáticamente en cada arranque, añade una línea al archivo /etc/fstab. Primero, obtén el UUID:

sudo blkid /dev/sdb1

Luego edita el archivo:

sudo nano /etc/fstab

Y añade una línea como esta (cambia el UUID por el tuyo):

UUID=xxxx-xxxx /mnt/disco_nuevo ext4 defaults 0 2

Conclusión

Añadir un nuevo disco en Linux puede parecer complicado al principio, pero con unos pocos comandos puedes ampliar tu sistema de forma flexible. Esta es una gran forma de familiarizarte con la gestión de dispositivos de almacenamiento en Linux.

¿Has probado a añadir un disco en tu sistema Linux? ¿Te surgió alguna duda durante el proceso? ¡Cuéntanos tu experiencia en los comentarios!

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Cómo añadir un nuevo disco duro en Linux paso a paso se publicó primero en Linux Básico.

¡Hola a todos y bienvenidos! En esta guía vamos a aprender cómo crear un cluster en Proxmox paso a paso. Un cluster es un grupo de servidores que trabajan juntos para ofrecer alta disponibilidad, escalabilidad y facilidad de gestión.

Proxmox VE es una plataforma de virtualización basada en Linux que permite administrar máquinas virtuales y contenedores de forma centralizada. En este tutorial, vamos a montar un cluster de dos nodos con almacenamiento compartido, para poder migrar las máquinas virtuales entre servidores sin interrupciones ni pérdida de datos.

Requisitos previos

• Dos servidores físicos con Proxmox VE instalado y con la misma versión.
• Una red local que conecte ambos servidores (se recomienda una red dedicada para el cluster).
• Un sistema de almacenamiento compartido accesible por ambos nodos, ya sea vía NFS o iSCSI.

1. Crear el cluster en el primer nodo

Desde la interfaz web de Proxmox (nodo 1):

1. Accede a Datacenter → Cluster.
2. Haz clic en Create Cluster.
3. Introduce un nombre para el cluster y selecciona el nodo.
4. Confirma y espera a que termine la creación.

2. Añadir el segundo nodo al cluster

Desde la interfaz del nodo 2:

1. Ve a Datacenter → Cluster.
2. Haz clic en Join Cluster y copia el comando que se muestra.
3. Entra al nodo 2 por SSH y ejecuta el comando copiado.
4. Introduce la IP del nodo 1, la contraseña de root y acepta el certificado.

3. Configurar el almacenamiento compartido

Desde el nodo 1 (o desde Datacenter):

1. Ve a Datacenter → Storage → Add.
2. Elige el tipo de almacenamiento: iSCSI, NFS, Ceph, etc.
3. Introduce los parámetros: ID, dirección del portal, target o ruta NFS, etc.
4. Marca la opción Shared si está disponible.

4. Compartir el almacenamiento entre nodos

Una vez creado, edita el almacenamiento en Datacenter → Storage y asegúrate de que:

• Está marcado como Compartido.
• Está disponible en ambos nodos del cluster.

5. Crear una máquina virtual en el almacenamiento compartido

Al crear una nueva VM:

1. Haz clic en Create VM.
2. Selecciona como almacenamiento el recurso compartido.
3. Configura la VM como prefieras.

6. Migrar la máquina virtual entre nodos

Para migrar una VM desde el nodo 1 al nodo 2:

1. Haz clic derecho sobre la VM → Migrate.
2. Selecciona el nodo de destino.
3. Marca la opción Online Migration para evitar apagados.

Conclusión

Y con eso ya tienes un cluster funcional en Proxmox con almacenamiento compartido. Esta configuración te permite mover cargas de trabajo entre servidores sin interrupciones, mejorar la disponibilidad y facilitar tareas de mantenimiento.

¿Ya tienes montado tu cluster en Proxmox? ¿Qué tipo de almacenamiento compartido utilizas? ¡Cuéntanos tu experiencia en los comentarios!

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Cómo crear un cluster en Proxmox con almacenamiento compartido se publicó primero en Linux Básico.

Uno de los pasos clave para mantener un sistema Linux estable y eficiente es monitorizar el consumo de recursos y, cuando sea necesario, ajustar los límites de uso en los servicios. Esto es especialmente importante si tienes servidores con múltiples procesos corriendo al mismo tiempo o si administras sistemas con recursos limitados.

Medir el uso de recursos: comandos esenciales

Linux incluye herramientas muy potentes que nos permiten saber qué está pasando en nuestro sistema en tiempo real:

• top: Muestra los procesos más activos y su uso de CPU y memoria.
• htop: Una versión mejorada de top, más visual e interactiva (puedes instalarlo con sudo apt install htop o sudo yum install htop).
• free -h: Muestra el uso de memoria RAM y swap.
• vmstat: Muestra estadísticas sobre procesos, memoria, swap, disco y CPU.
• iostat: Útil para ver el uso de disco por parte de los procesos (requiere el paquete sysstat).
• pidstat: Permite ver el uso de recursos por proceso.

Estas herramientas te dan una visión clara de qué servicios están consumiendo más recursos y si hay cuellos de botella.

Ajustar los límites de recursos en los servicios

Una vez detectado un servicio que consume en exceso, puedes aplicar límites usando diferentes mecanismos:

1. Usar systemd con límites de recursos

Si el servicio está gestionado por systemd (lo más común hoy en día), puedes limitar su uso de CPU y memoria editando su unidad:

sudo systemctl edit nombre-del-servicio

Y añades algo como esto en el fichero de sobreescritura:

[Service] MemoryMax=512M CPUQuota=50% 

Después recarga systemd y reinicia el servicio:

sudo systemctl daemon-reexec sudo systemctl restart nombre-del-servicio

2. Usar ulimit para limitar procesos

Para procesos lanzados por shell, puedes limitar recursos con ulimit. Por ejemplo, para limitar la memoria virtual a 1 GB:

ulimit -v 1048576

Esto se aplica solo al proceso actual y sus hijos. Puedes configurar límites permanentes en /etc/security/limits.conf.

3. Contenedores o cgroups

Para un control más avanzado, puedes usar cgroups directamente o herramientas como Docker o systemd-nspawn, que permiten aislar servicios y asignarles recursos específicos de CPU, RAM o I/O.

Consejo final

Empieza por medir y entender qué está pasando. A veces el problema no es el consumo alto en sí, sino que un servicio no está bien optimizado o que otro proceso está interfiriendo. No pongas límites a ciegas: analiza, ajusta y monitoriza de nuevo.

¿Ya estás controlando el uso de recursos en tu sistema?

Cuéntanos en los comentarios qué herramientas usas o si has tenido que limitar algún servicio. ¡Compartir experiencias ayuda a toda la comunidad!

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Cómo medir el consumo de recursos en Linux y ajustar los límites en los servicios se publicó primero en Linux Básico.

¿Sabías que puedes disfrutar de tus juegos favoritos de Windows en Linux? Gracias a Proton, una herramienta integrada en Steam, jugar en Linux es más fácil de lo que parece. En esta guía te explico paso a paso cómo hacerlo, desde la instalación de Steam hasta cómo ejecutar juegos con Proton.

¿Qué es Proton?

Proton es una capa de compatibilidad desarrollada por Valve que permite ejecutar juegos de Windows en sistemas Linux. Está basada en Wine y DXVK, y viene integrada directamente en Steam, así que no necesitas configuraciones complicadas para empezar a jugar.

Cómo instalar Steam en Linux

Steam está disponible en los repositorios de la mayoría de distribuciones. Aquí te dejo los comandos para instalarlo según tu sistema:

# En Ubuntu, Linux Mint o Debian: 
sudo apt update 
sudo apt install steam 
# En Arch Linux o Manjaro: 
sudo pacman -S steam 
# En Fedora: 
sudo dnf install steam 

Una vez instalado, abre Steam desde el menú de aplicaciones e inicia sesión con tu cuenta.

Activar Proton en Steam

Para usar Proton con todos los juegos, sigue estos pasos dentro de Steam:

1. Ve a Parámetros o Preferencias.
2. Haz clic en Steam Play en el menú lateral.
3. Marca las opciones:
   • Habilitar Steam Play para títulos compatibles
   • Habilitar Steam Play para todos los títulos
4. Selecciona una versión de Proton (Proton Experimental o la más reciente disponible).
5. Reinicia Steam para aplicar los cambios.

Instalar juegos con Proton

Después de activar Steam Play, puedes instalar cualquier juego como lo harías en Windows:

1. Busca un juego en tu biblioteca o en la tienda de Steam.
2. Haz clic en Instalar.
3. Steam descargará el juego y lo ejecutará automáticamente con Proton.
4. Haz clic en Jugar y ¡listo!

¿Qué juegos funcionan en Linux?

Cada vez más juegos son compatibles gracias a Proton. Puedes guiarte por la etiqueta Steam Deck Verified o consultar la web ProtonDB, donde los usuarios valoran el rendimiento de cada título en Linux.

Consejos para mejorar la compatibilidad

• Instala los drivers gráficos propietarios si usas NVIDIA o AMD.
• Activa Vulkan, especialmente para juegos modernos.
• Prueba con otras versiones de Proton desde las propiedades del juego si no te funciona bien.

Conclusión

Jugar en Linux nunca ha sido tan fácil. Gracias a Steam y Proton, puedes disfrutar de una gran parte del catálogo de juegos sin necesidad de usar Windows. ¿Te animas a probarlo?

¿Qué juego fue el primero que probaste en Linux con Proton? Cuéntalo en los comentarios y ayuda a otros jugadores.

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Cómo jugar en Linux con Steam y Proton se publicó primero en Linux Básico.

MongoDB es una base de datos NoSQL ampliamente utilizada por su escalabilidad y flexibilidad. Sin embargo, si no se ajusta correctamente, puede convertirse en un cuello de botella para tus aplicaciones. En esta guía te explico cómo hacer tuning de MongoDB en servidores Linux para maximizar su rendimiento, con ejemplos prácticos y recomendaciones reales.

¿Por qué hacer tuning de MongoDB?

Por defecto, MongoDB está configurado para funcionar “de forma general”, pero cada entorno tiene requisitos distintos. Aplicar técnicas de tuning en MongoDB puede ayudarte a:

• Reducir latencias de escritura y lectura.
• Mejorar la respuesta bajo cargas altas.
• Aumentar la eficiencia del uso de memoria y CPU.
• Detectar cuellos de botella antes de que afecten al sistema.

Recomendaciones generales de tuning para MongoDB

1. Usa WiredTiger correctamente

WiredTiger es el motor de almacenamiento por defecto desde MongoDB 3.2. Asegúrate de que el parámetro cacheSizeGB esté bien dimensionado. Como regla general:

cacheSizeGB ≈ (RAM Total del sistema * 0.5) - RAM reservada para el sistema operativo y otros procesos

Ejemplo de ajuste:

storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 16

2. Ajusta los límites del sistema (ulimits)

Por defecto, muchos sistemas Linux imponen límites demasiado bajos para procesos como mongod.

Ajustes recomendados en /etc/security/limits.conf:

mongodb soft nofile 64000
mongodb hard nofile 64000
mongodb soft nproc 64000
mongodb hard nproc 64000

Y en /etc/systemd/system/mongod.service.d/override.conf:

[Service]
LimitNOFILE=64000

3. Desactiva Transparent Huge Pages (THP)

THP puede perjudicar gravemente el rendimiento de MongoDB.

Verifica si está activado:

cat /sys/kernel/mm/transparent_hugepage/enabled

Desactiva temporalmente:

echo never > /sys/kernel/mm/transparent_hugepage/enabled

Desactiva permanentemente: agrega al GRUB transparent_hugepage=never

4. Configura el commitIntervalMs en entornos con mucha escritura

Si tu sistema tiene mucha escritura continua, puedes ajustar commitIntervalMs para balancear durabilidad y rendimiento.

storage:
  journal:
    commitIntervalMs: 100

Métricas clave que debes monitorizar

• opcounters.insert, opcounters.query: tasa de operaciones
• mem.resident: uso de RAM por MongoDB
• connections.current: conexiones activas
• locks.*: bloqueos en colecciones o base de datos
• wiredTiger.cache.*: uso del cache interno

¿Tienes dudas sobre tu caso específico? ¡Déjalas en los comentarios y te ayudamos!

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Tuning de MongoDB en entornos Linux: Guía para mejorar el rendimiento se publicó primero en Linux Básico.

¿Estás empezando en el mundo de Linux y no sabes por dónde comenzar? Una de las mejores formas de entender este sistema operativo es aprendiendo a usar la terminal. Aunque al principio parezca compleja, pronto descubrirás que con unos pocos comandos básicos de Linux puedes controlar todo el sistema de forma sencilla, rápida y potente.

¿Qué es la terminal y por qué es tan importante?

La terminal es una herramienta que te permite comunicarte directamente con tu sistema operativo escribiendo comandos. A diferencia de las ventanas gráficas, aquí no haces clics: escribes instrucciones. Puede parecer más difícil, pero en realidad te da mucho más control y precisión.

Aprender a usarla te ayudará a entender mejor cómo funciona Linux y a resolver problemas más rápido.

Primeros pasos: comandos para moverte por el sistema

Empezaremos con comandos que te permiten explorar y moverte por tu sistema de archivos:

• pwd: Muestra tu ubicación actual (el directorio en el que estás trabajando).
• ls: Lista el contenido de un directorio. Prueba con ls -l o ls -a para ver más información.
• cd: Cambia de directorio. Por ejemplo, cd Documentos te lleva a esa carpeta.

Ejemplo práctico:

pwd
/home/usuario

ls
Documentos  Descargas  Música

cd Documentos
ls
currículum.pdf  notas.txt

Crear, copiar y mover archivos y carpetas

Estos comandos son esenciales para organizar tu información:

• mkdir nueva_carpeta: Crea un nuevo directorio.
• touch archivo.txt: Crea un archivo vacío llamado archivo.txt.
• cp origen destino: Copia un archivo. Ejemplo: cp notas.txt copia.txt
• mv archivo carpeta/: Mueve un archivo. También se usa para renombrar: mv viejo.txt nuevo.txt

Ejemplo práctico:

mkdir proyecto
cd proyecto
touch ideas.txt
echo "Primera idea" > ideas.txt
cp ideas.txt copia.txt
mkdir antiguos
mv copia.txt antiguos/

Eliminar archivos y carpetas

¡Cuidado! Aquí no hay papelera: lo que borres, desaparece directamente.

• rm archivo.txt: Elimina un archivo.
• rm -r carpeta: Borra una carpeta y todo su contenido.

rm viejo.txt
rm -r carpeta_antigua

Ver el contenido de archivos

• cat: Muestra el contenido completo de un archivo.
• head: Muestra las primeras líneas de un archivo.
• tail: Muestra las últimas líneas (muy útil para logs).

cat ideas.txt
head ideas.txt
tail ideas.txt

Buscar archivos y contenido dentro de archivos

• find: Busca archivos por nombre. Ejemplo: find . -name "*.txt"
• grep: Busca texto dentro de archivos. Ejemplo: grep "contraseña" *.txt

find /home/usuario -name "notas.txt"
grep "Linux" notas.txt

Conocer más sobre cada comando

• man: Muestra el manual de un comando. Por ejemplo: man ls
• –help: Casi todos los comandos aceptan la opción --help. Ejemplo: cp --help

Ejercicio para practicar

Haz lo siguiente paso a paso para familiarizarte con varios comandos:

mkdir prueba_terminal
cd prueba_terminal

touch uno.txt dos.txt tres.txt
echo "Bienvenido al mundo Linux" > uno.txt

cp uno.txt copia_uno.txt
cat copia_uno.txt

rm uno.txt

cd ..
rm -r prueba_terminal

Conclusión

Estos comandos básicos de Linux son solo el inicio. A medida que ganes confianza, podrás combinarlos y aprender comandos más avanzados. Lo más importante es practicar sin miedo, entender lo que hace cada orden y aprovechar el poder de la terminal para controlar tu sistema.

¿Cuál de estos comandos te gustaría dominar mejor? Cuéntanos en los comentarios y dinos si te gustaría que preparemos una segunda parte con comandos para gestionar procesos o permisos.

Iñaki Méndez

Técnico informático especializado en Linux, redes y ciberseguridad. Apasionado del software libre, comparto tutoriales y guías prácticas en Linuxbasico para ayudarte a dominar el entorno Linux desde cero.

La entrada Comandos básicos de Linux para empezar con la terminal se publicó primero en Linux Básico.

En el mundo digital actual, el malware es una amenaza constante que puede afectar tanto a individuos como a organizaciones.
A continuación, exploraremos los tipos más comunes de malware y ofreceremos consejos prácticos para evitar la infección de los tipos de malware y como prevenirlos.

1. Virus

Un virus es un tipo de malware que se adjunta a archivos legítimos y se propaga cuando esos archivos se comparten. Puede dañar archivos, robar información o incluso tomar el control de tu sistema.

Consejo: Mantén tu software antivirus actualizado y realiza escaneos regulares para detectar y eliminar virus.

2. Gusanos

Los gusanos son programas maliciosos que se replican a sí mismos y se propagan a través de redes sin necesidad de intervención humana. Pueden consumir recursos del sistema y causar daños significativos.

Consejo: Asegúrate de tener un firewall activo y configura tu red para que sea segura, limitando el acceso no autorizado.

3. Troyanos

Los troyanos se disfrazan de software legítimo para engañar a los usuarios y hacer que los instalen. Una vez dentro, pueden abrir puertas traseras para que otros tipos de malware entren en tu sistema.

Consejo: Descarga software solo de fuentes confiables y verifica las reseñas y la reputación del desarrollador antes de instalar cualquier programa.

4. Ransomware

El ransomware cifra los archivos de tu sistema y exige un rescate para desbloquearlos. Este tipo de malware puede ser devastador tanto para individuos como para empresas.

Consejo: Realiza copias de seguridad regulares de tus datos y almacénalas en ubicaciones seguras y desconectadas de tu red principal.

5. Spyware

El spyware se instala en tu dispositivo sin tu conocimiento y recopila información sobre ti, como contraseñas y datos personales, que luego se envían a terceros.

Consejo: Utiliza herramientas anti-spyware y evita hacer clic en enlaces sospechosos o descargar archivos de fuentes no verificadas, como sms sospechosos o correos de fuentes sospechosos.

6. Adware

El adware muestra anuncios no deseados en tu dispositivo y puede redirigirte a sitios web maliciosos. Aunque no siempre es dañino, puede ser muy molesto y ralentizar tu sistema.

Consejo: Instala bloqueadores de anuncios y mantén tu navegador y sus extensiones actualizados para evitar la instalación de adware.

7. Rootkits

Los rootkits son programas que permiten a los atacantes obtener acceso no autorizado a tu sistema y ocultar su presencia. Son difíciles de detectar y eliminar.

Consejo: Utiliza herramientas de detección de rootkits y mantén tu sistema operativo y software de seguridad actualizados.

Espero que esta guía te sea útil para protegerte contra las diversas amenazas y los tipos de malware y como prevenirlos. ¡Mantente seguro en el mundo digital!

Aitzol Tola

Soy un Técnico Informático con una gran pasión hacia las nuevas tecnologías.

aitzoltola.com

La entrada Los Distintos Tipos de Malware y Cómo Protegerte se publicó primero en Linux Básico.

Los principios S.O.L.I.D, como grupo, fueron recopilados, explicados y popularizados por Robert C. Martin hace aproximadamente 20 años. Sus primeros artículos sobre ellos circularon a finales de los años 90 y los principios fueron cubiertos extensamente en su libro “Desarrollo de Software Ágil: Principios, Patrones y Prácticas”, publicado en 2002. Constituyen otro intento de crear una teoría de programación, un conjunto de principios para guiar cómo escribimos y estructuramos el código. S.O.L.I.D es un acrónimo formado por la primera letra de cada principio:

• S (Principio de Responsabilidad Única)
• O (Principio Abierto/Cerrado)
• L (Principio de Sustitución de Liskov)
• I (Principio de Segregación de la Interfaz)
• D (Principio de Inversión de Dependencias)

El beneficio de S.O.L.I.D es que estos son principios más concretos que las ideas abstractas de acoplamiento y cohesión. Nos permiten apuntar a reducir el acoplamiento y aumentar la cohesión a través de métodos más prácticos.

Estos principios son simples en su formulación, pero son extremadamente profundos en su aplicación. Simplemente conocer la definición no es suficiente para incorporar las ideas en lo que hacemos; necesitamos realmente involucrarnos con estos principios, discutirlos mientras hacemos nuestro trabajo y especialmente mientras practicamos deliberadamente, ya que de esta manera podremos utilizar estos principios de manera efectiva.

Conocer cada principio de forma aislada es bueno. Pero aplicar todos estos principios como un bloque sólido es cuando realmente se vuelven poderosos.

El Principio de Responsabilidad Única

“Una clase debería tener solo una razón para cambiar”.

Robert C. Martin reconoce que este principio es muy similar al concepto de cohesión desarrollado por muchos otros autores desde finales de los años 70, pero su formulación es sutilmente diferente. En lugar de pensar en la cohesión de una clase y aplicar varios análisis para calcular una puntuación de cohesión, él dice que si hay más de una razón para que una clase cambie, entonces está haciendo demasiado y debería dividirse en dos clases, cada una haciendo una sola cosa.

Aunque esto suena bastante simple, también es probablemente el más difícil de estos principios de llevar a la práctica. No siempre conocemos la forma en que las cosas van a cambiar, por ejemplo. No es una buena idea segregar cosas que nunca van a cambiar porque entonces estamos haciendo un trabajo adicional que es innecesario. Por lo tanto, necesitamos pensar y posiblemente predecir la forma en que las cosas pueden cambiar en el futuro. Esto es difícil, y es probable que no lo hagamos bien la mayor parte del tiempo. Luego, un año después, alguien preguntará “¡¿por qué no separaste esta parte de la clase – no seguiste el SRP?!”

La clave aquí es darse cuenta cuando se está cambiando una clase de más de una manera y buscar separar las partes que están cambiando. Una forma de descubrir qué clases están cambiando es usar el historial de control de origen para generar un mapa de calor de su código: las clases que se están modificando a menudo durante un largo período probablemente estén haciendo demasiado (también podrían estar violando el Principio Abierto/Cerrado).

El Principio Abierto/Cerrado

“Las entidades de software (clases, módulos, funciones, etc.) deberían estar abiertas para su extensión pero cerradas para su modificación”.

Este principio seguido al extremo significaría que cada vez que queramos agregar funcionalidad, creamos una nueva clase o una nueva función y nunca cambiamos el código existente. Por supuesto, este no es un sueño realista, pero es una idea hacia la cual podemos trabajar. ¿Por qué? Porque usando este enfoque podemos agregar funcionalidad a un sistema sin romper la funcionalidad existente y sin causar cambios secundarios. Si podemos recomponer cosas de diferentes maneras para lograr diferentes resultados sin reescribir las piezas que estamos usando para componer nuestra solución, entonces hemos logrado un nivel de flexibilidad muy poderoso.

Cuando los módulos están alineados con el Principio Abierto/Cerrado, exhiben dos atributos como se menciona en la definición del principio. Son:

• Abiertos para extensión. Esto significa que el módulo puede ser extendido de alguna manera para cambiar su comportamiento.
• Cerrados para modificación. Si bien el módulo puede ser extendido para cambiar su comportamiento, no es necesario cambiar su código fuente. Idealmente, podríamos extender el comportamiento del módulo sin siquiera necesitar volver a compilar el binario.

Este principio no es realmente posible de seguir en un lenguaje procedural porque depende de alguna forma de abstracciones y polimorfismo para lograrlo.

Un Ejemplo:

Lo clásico de este principio es una declaración de switch que cambia en una enumeración u otra variable. Esta declaración switch casi siempre puede ser reemplazada por una jerarquía de clases que utiliza polimorfismo para ejecutar el método correcto; esta es la que sigue el PACO porque se puede inyectar un nuevo comportamiento agregando otra clase con un nuevo método polimórfico.

Al igual que con nuestra advertencia con el SRP, no siempre es posible anticipar las formas en que una clase necesitará ser extendida. La idea es usar nuestra experiencia para anticipar las formas en que una clase/módulo probablemente necesitará ser extendida y asegurarnos de que esté abierta para la extensión en esa área. Una vez más, utilizando el ejemplo de un deserializador, es muy probable que queramos extender esto agregando nuevos tipos de fuentes para los bytes a deserializar, por lo que necesitamos asegurarnos de que esté abierto para la extensión en esa área proporcionando una manera de enchufar una estrategia.

El Principio de Sustitución de Liskov

“Los subtipos deben ser sustituibles por sus tipos base”.

Cualquiera que haya usado herencia probablemente haya violado este principio muchas veces sin saberlo. En varias ocasiones, he heredado de una clase base y proporcionado anulaciones que simplemente lanzan una NotImplementedException() o similar. Esta subclase está violando el Principio de Sustitución de Liskov porque este subtipo no es sustituible por el tipo base en todas las circunstancias. Sin embargo, todavía hay momentos en que esto es conveniente. Un buen ejemplo es la biblioteca ADO.NET: no todos los proveedores de bases de datos implementan todas las características definidas por ADO.NET, pero la mayoría de ellos implementan la mayoría de las características, y sería muy difícil separar cada característica en diferentes interfaces, por lo que tiene más sentido simplemente lanzar algunas NotImplementedExceptions() aquí o allá que tratar de asegurar que el LSP nunca se viole.

Una forma de asegurar que se siga el LSP es separar las interfaces; es decir, seguir el Principio de Segregación de la Interfaz. Entonces, sus subtipos solo necesitarán implementar las interfaces que se apliquen directamente.

El Principio de Segregación de la Interfaz

“Los clientes no deben estar obligados a depender de métodos que no utilizan”.

Este principio es esencialmente un reconocimiento de que las clases cohesivas son un ideal y no siempre son posibles. Hay momentos en los que necesitamos construir una clase que tenga un gran conjunto de métodos en su interfaz; por ejemplo, cuando construimos una fachada que actúa como el adaptador para varios sistemas de backend diferentes. Sin embargo, el Principio de Segregación de la Interfaz dice que esta interfaz grande debería dividirse en secciones dependiendo de las necesidades de los diferentes tipos de clientes que se conectarán a ella.

Es decir, si hay un conjunto de métodos que será utilizado por un tipo de cliente y un conjunto diferente de métodos utilizado por otro, entonces estos métodos deberán dividirse en dos interfaces diferentes para que cada tipo de cliente pueda depender de una interfaz abstracta específica que solo contenga los métodos que se necesiten, en lugar de depender de la interfaz grande en sí misma.

La segregación de interfaces proporciona una forma de desacoplar las clases cliente. Si dos clases cliente diferentes dependen de una API concreta, entonces los cambios realizados en la API en beneficio de una clase cliente afectarán a la otra clase cliente, incluso si esos cambios no se hicieron en los métodos que necesita esa clase cliente. Esto significa que las dos clases cliente están acopladas entre sí a través de su dependencia común en la API. Si esa API se divide en dos interfaces segregadas diferentes y cada clase cliente depende de una diferente, entonces los cambios realizados en las implementaciones concretas solo afectarán al cliente que utiliza la interfaz afectada. Esto significa que las dos clases cliente ya no están acopladas entre sí.

El Principio de Inversión de Dependencias

“A. Los módulos de alto nivel no deben depender de los módulos de bajo nivel. Ambos deben depender de abstracciones. B. Las abstracciones no deben depender de detalles. Los detalles deben depender de abstracciones”.

Yo argumentaría que este es el principio S.O.L.I.D más ampliamente implementado. La idea está incrustada en cada “contenedor” que existe y ahora está mucho más integrada en frameworks como ASP.NET MVC.

La idea en el Principio de Inversión de Dependencias es invertir las dependencias naturales que normalmente surgen al codificar; por ejemplo, si está construyendo una interfaz de usuario y necesita llamar a una capa de datos para acceder a una base de datos, normalmente simplemente instanciaría un objeto de la capa de datos y lo llamaría. Esto es lo que Robert C. Martin llama el método procedimental tradicional. Él argumenta que el método orientado a objetos bien factorizado, sin embargo, es que la interfaz de usuario dependa de una abstracción de la capa de datos y tenga la implementación concreta dada para que esta dependencia tradicional se invierta.

Beneficios:

• Reducción del acoplamiento entre clases concretas, lo que significa que cada una de ellas puede cambiar de manera aislada.
• Permitir nuevas implementaciones de la capa de datos sin afectar la interfaz de usuario (el principio abierto/cerrado).
• Permitir la inserción de decoradores u otras clases incluso en tiempo de ejecución o dependiendo de la configuración: por ejemplo, podríamos crear una capa de datos de registro que use la implementación de la capa de datos original pero agregue registro a ella.
• Dependiendo de abstracciones significa que nuestras clases son menos frágiles ya que las abstracciones cambian con menos frecuencia que los detalles de implementación.
• Probar cada una de las clases puede hacerse de manera aislada; no necesitamos una capa de datos concreta para probar la interfaz de usuario.

Aitzol Tola

Soy un Técnico Informático con una gran pasión hacia las nuevas tecnologías.

aitzoltola.com

La entrada Principios S.O.L.I.D se publicó primero en Linux Básico.

Los archivos temporales de Windows, son aquellos que se crean por el sistema operativo o por las aplicaciones que se ejecutan en él para almacenar datos de forma temporal. Estos archivos pueden ocupar espacio en el disco duro y ralentizar el rendimiento del equipo si no se eliminan periódicamente. Además, algunos archivos temporales pueden contener información sensible o privada que no queremos que quede expuesta a terceros.

También puede ser una buena manera de evitar problemas o sobre esfuerzo innecesario del sistema operativo con archivos que no están en uso.

Formas de hacerlo

Por estas razones, es conveniente borrar los archivos temporales de Windows de forma regular. A continuación, te presentamos algunas opciones para llevar a cabo esta tarea:

1. Usar el Liberador de espacio en disco de Windows:
   • El Liberador de espacio en disco es una herramienta integrada en Windows que permite seleccionar los tipos de archivos que queremos eliminar, como los archivos temporales de Internet, los archivos de la papelera de reciclaje, los informes de errores o los puntos de restauración del sistema.
   • Para acceder a esta herramienta, podemos escribir “Liberador de espacio en disco” en el buscador de Windows o hacer clic derecho sobre la unidad C: y elegir “Propiedades” y luego “Liberar espacio”.
2. Usar programas externos especializados:
   • Existen programas externos especializados en limpiar el sistema, como CCleaner, Glary Utilities o Disk Cleaner. Estos programas suelen ofrecer más opciones y funciones que la herramienta nativa de Windows, como limpiar el registro, desinstalar programas o borrar el historial del navegador.
   • Sin embargo, es importante tener cuidado al usar estos programas y revisar bien las opciones que seleccionamos para evitar borrar algo importante o dañar el sistema.
3. Borrar manualmente los archivos temporales:
   • Esta opción es la menos recomendable porque puede ser más laboriosa y arriesgada. Para ello, tenemos que ir a la carpeta C:\Windows\Temp y seleccionar todos los archivos y carpetas que queramos eliminar. También podemos ir a la carpeta C:\Users\NombreDeUsuario\AppData\Local\Temp y hacer lo mismo.
   • Hay que tener en cuenta que algunos archivos pueden estar en uso por el sistema o por alguna aplicación y no se podrán borrar.

En conclusión

Borrar los archivos temporales de Windows es una buena práctica para mantener nuestro equipo limpio y optimizado. Podemos usar diferentes métodos para hacerlo según nuestras preferencias y necesidades.

Recuerda que, al eliminar archivos temporales, es importante no borrar archivos importantes del sistema que puedan afectar su funcionamiento. Si no estás seguro de qué archivos puedes eliminar, es recomendable buscar orientación o asistencia técnica adecuada.

Los archivos temporales de Windows son aquellos que se crean por el sistema operativo o por las aplicaciones que se ejecutan en él para almacenar datos de forma temporal. Estos archivos pueden ocupar espacio en el disco duro y ralentizar el rendimiento del equipo si no se eliminan periódicamente. Además, algunos archivos temporales pueden contener información sensible o privada que no queremos que quede expuesta a terceros.

Por estas razones, es conveniente borrar los archivos temporales de Windows de forma regular.

Aitzol Tola

Soy un Técnico Informático con una gran pasión hacia las nuevas tecnologías.

aitzoltola.com

La entrada Cómo borrar archivos temporales en Windows se publicó primero en Linux Básico.