Informe de memoria en Linux

Introducción

La gestión de memoria es un aspecto crítico de la administración de sistemas Linux que afecta directamente el rendimiento y la estabilidad del sistema. Comprender cómo se asigna, utiliza y reporta la memoria en los sistemas Linux permite a los administradores optimizar el rendimiento, solucionar problemas y garantizar suficientes recursos para las aplicaciones.

En este laboratorio (lab), aprenderá cómo monitorear y analizar el uso de memoria en sistemas Linux utilizando herramientas de línea de comandos. Explorará el comando free, que proporciona información esencial sobre la asignación y el uso de la memoria del sistema. Al dominar estas herramientas, adquirirá las habilidades necesarias para monitorear eficazmente los recursos de memoria del sistema y tomar decisiones informadas sobre la optimización del sistema.

Al final de este laboratorio (lab), podrá verificar el estado de la memoria del sistema, interpretar las estadísticas de memoria y crear informes básicos de uso de memoria, que son habilidades fundamentales para cualquier usuario de Linux o administrador de sistemas.

Uso del comando básico free

El comando free es una utilidad fundamental de Linux que muestra la cantidad de memoria libre y utilizada en su sistema. Esta información le ayuda a entender el estado actual de la memoria de su sistema y determinar si tiene suficientes recursos para sus aplicaciones.

Ejecución del comando básico free

Abra su terminal en el espacio de trabajo predeterminado en /home/labex/project y ejecute el comando básico free:

free

Debería ver una salida similar a esta:

               total        used        free      shared  buff/cache   available
Mem:         8000000     3000000     1000000       25000     4000000     4700000
Swap:             0           0           0

La salida muestra los valores de memoria en bytes, lo que puede ser difícil de leer. Para un formato más legible, utilice la opción -h (human-readable, legible para humanos):

free -h

Ahora la salida se verá más así:

               total        used        free      shared  buff/cache   available
Mem:           7.6Gi       2.9Gi       954Mi        24Mi       3.8Gi       4.5Gi
Swap:             0B          0B          0B

Este formato muestra los tamaños de memoria con unidades adecuadas (KB, MB, GB), lo que lo hace mucho más fácil de interpretar.

Creación de un directorio para su trabajo

Vamos a crear un directorio para almacenar los archivos que creará durante este laboratorio (lab):

mkdir -p ~/project/memory_data

Guardado de las estadísticas de memoria en un archivo

Ahora, guardemos la salida del comando free -h en un archivo para futuras referencias:

free -h > ~/project/memory_data/memory_stats.txt

Para verificar que el archivo se haya creado y contenga la información esperada, utilice el comando cat:

cat ~/project/memory_data/memory_stats.txt

Debería ver la misma salida que se mostró previamente en su terminal.

Comprendiendo las columnas de salida de memoria

Ahora que tiene las estadísticas básicas de memoria, comprendamos lo que significa cada columna en la salida del comando free. Este conocimiento le ayudará a interpretar el estado de la memoria del sistema de manera más efectiva.

Explicación de las columnas de la salida de memoria

Abra el archivo de estadísticas de memoria que creó en el paso anterior:

cat ~/project/memory_data/memory_stats.txt

La salida contiene varias columnas:

total: La cantidad total de memoria (RAM) instalada en el sistema.
used: La cantidad de memoria que actualmente está siendo utilizada por el sistema.
free: La cantidad de memoria que actualmente no se está utilizando para nada.
shared: Memoria compartida por múltiples procesos, a menudo utilizada por tmpfs (sistemas de archivos temporales) y segmentos de memoria compartida.
buff/cache: Memoria utilizada por los buffers del kernel y la caché de páginas:
- buffers: Memoria utilizada por el kernel para almacenar temporalmente datos antes de escribirlos en el disco.
- caches: Memoria utilizada para almacenar datos leídos del disco para un acceso más rápido.
available: Una estimación de cuánta memoria está disponible para iniciar nuevas aplicaciones sin utilizar el intercambio (swap).

Creación de un informe de memoria

Ahora, creemos un informe detallado de memoria que explique lo que significa cada columna y registre los valores actuales. Cree un nuevo archivo llamado memory_report.txt:

nano ~/project/memory_data/memory_report.txt

En el editor nano, agregue el siguiente contenido (reemplace los valores de marcador de posición con los valores reales de su sistema):

Informe de memoria - Creado el $(date)

total: [Su valor aquí]
La cantidad total de RAM física instalada en el sistema.

used: [Su valor aquí]
La cantidad de memoria que actualmente está siendo utilizada por las aplicaciones y el sistema operativo.

free: [Su valor aquí]
La cantidad de memoria que está completamente sin usar y disponible.

shared: [Su valor aquí]
Memoria utilizada por tmpfs y segmentos de memoria compartida que pueden ser accedidos por múltiples procesos.

buff/cache: [Su valor aquí]
Memoria utilizada para los buffers del kernel y la caché de disco para mejorar el rendimiento del sistema.

available: [Su valor aquí]
Una estimación de cuánta memoria está disponible para iniciar nuevas aplicaciones sin intercambio (swap).

Para obtener los valores actuales, puede consultar el archivo memory_stats.txt que guardó previamente.

Después de agregar el contenido, guarde el archivo presionando Ctrl+O y luego Enter, luego salga de nano presionando Ctrl+X.

Visualización de la memoria en diferentes unidades

El comando free le permite mostrar la memoria en diferentes unidades. Creemos un archivo que muestre la memoria en varias unidades:

free -b | head -2 > ~/project/memory_data/memory_units.txt
echo "Memoria en bytes (arriba)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -k | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memoria en kilobytes (arriba)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -m | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memoria en megabytes (arriba)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -g | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memoria en gigabytes (arriba)" >> ~/project/memory_data/memory_units.txt

Vea el archivo para ver la memoria representada en diferentes unidades:

cat ~/project/memory_data/memory_units.txt

Esto le ayuda a entender cómo mostrar la información de memoria en la unidad más adecuada para sus necesidades.

Monitoreo de memoria en tiempo real

Los administradores de sistemas a menudo necesitan monitorear el uso de memoria a lo largo del tiempo para detectar tendencias o solucionar problemas. En este paso, aprenderá cómo monitorear el uso de memoria en tiempo real y crear un script sencillo para registrar el uso de memoria a intervalos regulares.

Uso del comando watch con free

El comando watch le permite ejecutar un comando periódicamente y mostrar su salida. Esto es muy útil para monitorear el uso de memoria en tiempo real:

watch -n 2 free -h

Este comando ejecuta free -h cada 2 segundos y muestra la salida actualizada. Debería ver las estadísticas de memoria actualizándose en tiempo real.

Para salir del comando watch, presione Ctrl+C.

Uso de free con la opción de intervalo

El propio comando free puede mostrar el uso de memoria a intervalos regulares. La sintaxis es:

free -s [segundos] -c [cantidad]

Donde:

-s especifica el intervalo en segundos entre actualizaciones
-c especifica cuántas actualizaciones se deben mostrar

Monitoreemos el uso de memoria cada 3 segundos durante un total de 4 actualizaciones:

free -h -s 3 -c 4

Esto mostrará las estadísticas de memoria 4 veces, con una pausa de 3 segundos entre cada actualización.

Creación de un script de monitoreo de memoria

Creemos un script que registre la información de uso de memoria a intervalos regulares. Primero, cree un nuevo archivo de script:

nano ~/project/memory_data/memory_monitor.sh

Agregue el siguiente contenido al archivo:

#!/bin/bash

## Crea un archivo de registro con la fecha y hora actual
log_file=~/project/memory_data/memory_log_$(date +%Y%m%d_%H%M%S).txt

## Escribe el encabezado en el archivo de registro
echo "Registro de uso de memoria - Iniciado a las $(date)" > $log_file
echo "Monitoreando cada 5 segundos durante 5 lecturas" >> $log_file
echo "----------------------------------------" >> $log_file

## Bucle 5 veces, capturando la información de memoria cada 5 segundos
for i in {1..5}; do
  echo "Lectura $i - $(date)" >> $log_file
  free -h >> $log_file
  echo "----------------------------------------" >> $log_file
  sleep 5
done

echo "Monitoreo completado a las $(date)" >> $log_file
echo "Registro guardado en $log_file"

Guarde el archivo presionando Ctrl+O, luego Enter, y salga con Ctrl+X.

Ahora, haga el script ejecutable:

chmod +x ~/project/memory_data/memory_monitor.sh

Ejecute el script:

~/project/memory_data/memory_monitor.sh

El script se ejecutará durante aproximadamente 25 segundos (5 segundos × 5 lecturas) y creará un archivo de registro con la información de uso de memoria. Después de que se complete, verá un mensaje que indica dónde se guardó el archivo de registro.

Para ver el archivo de registro:

cat ~/project/memory_data/memory_log_*

Este archivo de registro muestra cómo cambia el uso de memoria a lo largo del tiempo, lo cual es valioso para solucionar problemas relacionados con la memoria o entender los patrones de uso de memoria.

Explorando información avanzada de memoria

Linux proporciona información de memoria más detallada de lo que muestra el comando básico free. En este paso, explorará fuentes adicionales de información de memoria y creará un resumen completo de la memoria.

Exploración de /proc/meminfo

El archivo /proc/meminfo contiene información detallada de memoria sobre su sistema. Examinémoslo:

head -20 /proc/meminfo

Este archivo contiene docenas de valores relacionados con la memoria, incluyendo:

MemTotal: RAM total utilizable
MemFree: Memoria libre
MemAvailable: Memoria disponible
Buffers: Memoria utilizada por los buffers del kernel
Cached: Memoria utilizada para el caché de archivos
SwapTotal: Espacio total de intercambio (swap)
SwapFree: Espacio libre de intercambio (swap)

Extraigamos alguna información clave de este archivo:

grep -E "MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree" /proc/meminfo > ~/project/memory_data/meminfo_excerpt.txt

Veamos la información extraída:

cat ~/project/memory_data/meminfo_excerpt.txt

Creación de un resumen completo de memoria

Ahora, creemos un script que genere un informe resumen completo de la memoria. Creemos un nuevo archivo de script:

nano ~/project/memory_data/create_summary.sh

Agreguemos el siguiente contenido:

#!/bin/bash

## Establece el archivo de salida con la marca de tiempo
output_file=~/project/memory_data/memory_summary_$(date +%Y%m%d_%H%M%S).txt

## Crea el encabezado
echo "INFORME RESUMEN DE MEMORIA DE LINUX" > $output_file
echo "===========================" >> $output_file
echo "Fecha: $(date)" >> $output_file
echo "" >> $output_file

## Estadísticas básicas de memoria
echo "ESTADÍSTICAS BÁSICAS DE MEMORIA:" >> $output_file
free -h >> $output_file
echo "" >> $output_file

## Información detallada de memoria
echo "INFORMACIÓN DETALLADA DE MEMORIA:" >> $output_file
echo "Total RAM: $(grep MemTotal /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Free RAM: $(grep MemFree /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Available RAM: $(grep MemAvailable /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Buffer memory: $(grep Buffers /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Cache memory: $(grep "^Cached:" /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "" >> $output_file

## Información de intercambio (swap)
echo "INFORMACIÓN DE INTERCAMBIO (SWAP):" >> $output_file
echo "Total Swap: $(grep SwapTotal /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Free Swap: $(grep SwapFree /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "" >> $output_file

## Cálculo del porcentaje de uso de memoria
total_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
used_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
used_mem=$((used_mem - $(grep MemFree /proc/meminfo | awk '{print $2}')))
used_mem=$((used_mem - $(grep Buffers /proc/meminfo | awk '{print $2}')))
used_mem=$((used_mem - $(grep "^Cached:" /proc/meminfo | awk '{print $2}')))
mem_percentage=$((used_mem * 100 / total_mem))

echo "RESUMEN DE USO DE MEMORIA:" >> $output_file
echo "Porcentaje de uso de memoria: ${mem_percentage}%" >> $output_file
echo "" >> $output_file

echo "Informe resumen de memoria generado en $output_file"

Guarde el archivo presionando Ctrl+O, luego Enter, y salga con Ctrl+X.

Haga el script ejecutable:

chmod +x ~/project/memory_data/create_summary.sh

Ejecute el script para generar el informe resumen:

~/project/memory_data/create_summary.sh

Después de que el script se complete, vea el informe resumen generado:

cat ~/project/memory_data/memory_summary_*

Este informe completo le ofrece una vista detallada del estado de la memoria de su sistema al combinar datos de múltiples fuentes.

Creación de un comando simple de estado de memoria

Finalmente, creemos un comando simple de una sola línea que muestre el estado actual de la memoria en un formato conciso:

echo "Memory status: $(free -h | grep Mem | awk '{print "Total:"$2, "Used:"$3, "Free:"$4, "Available:"$7}')" > ~/project/memory_data/memory_status.txt

Veamos el estado de la memoria:

cat ~/project/memory_data/memory_status.txt

Este comando extrae la información más importante de la salida del comando free y la presenta en un formato compacto.

Resumen

En este laboratorio, has explorado técnicas esenciales para monitorear y analizar el uso de memoria en sistemas Linux. Has avanzado desde informes básicos de memoria hasta análisis avanzados, adquiriendo habilidades valiosas para la administración de sistemas y la resolución de problemas.

Conceptos clave y habilidades que has aprendido:

Informes básicos de memoria: Has utilizado el comando free para ver las estadísticas básicas de memoria y has aprendido a interpretar las columnas de la salida.
Comprensión de las métricas de memoria: Has explorado lo que significa cada métrica de memoria (total, utilizada, libre, compartida, buff/cache, disponible) y cómo mostrar la memoria en diferentes unidades.
Monitoreo en tiempo real: Has aprendido cómo monitorear el uso de memoria en tiempo real utilizando el comando watch y has creado un script para registrar el uso de memoria a intervalos regulares.
Análisis avanzado de memoria: Has explorado información detallada de memoria del archivo /proc/meminfo y has creado informes resumen completos de memoria.

Estas habilidades son esenciales para una administración efectiva de sistemas, ya que la gestión de memoria impacta directamente en el rendimiento del sistema. Al monitorear el uso de memoria, puedes:

Identificar problemas de rendimiento relacionados con la memoria
Determinar si un sistema necesita más recursos
Comprender cómo las aplicaciones utilizan la memoria
Detectar fugas de memoria o un uso excesivo de memoria
Tomar decisiones informadas sobre la optimización del sistema

Las técnicas que has aprendido en este laboratorio proporcionan una base sólida para la gestión de memoria en sistemas Linux y se pueden ampliar con herramientas de monitoreo más avanzadas y técnicas de automatización.