Cuando administramos un servidor Linux es muy habitual necesitar localizar una determinada cadena de texto dentro de los archivos del sistema. Por ejemplo, podemos necesitar encontrar dónde está definida una configuración, localizar una dirección IP, buscar una variable, comprobar dónde aparece una determinada palabra o localizar una referencia dentro de archivos de configuración.

Para realizar este tipo de búsquedas, una de las herramientas fundamentales de Linux es grep.

grep permite buscar patrones dentro del contenido de uno o varios archivos y mostrar las líneas que contienen coincidencias.

1. Buscar una cadena dentro de un archivo

La forma más sencilla es:

grep "cadena" archivo

Por ejemplo:

grep "localhost" configuracion.conf

Si el archivo contiene:

server=localhost
database=localhost

grep mostrará las líneas que contienen la cadena buscada.

2. Buscar dentro de todos los archivos de una carpeta

Si queremos buscar una cadena dentro de todos los archivos de un directorio:

grep -r "cadena" .

El punto (.) significa el directorio actual.

Por ejemplo:

grep -r "localhost" .

Esto buscará localhost dentro de los archivos del directorio actual y también dentro de sus subdirectorios.

La opción -r significa --recursive y hace que grep recorra recursivamente los directorios.

3. Mostrar el número de línea

Para saber exactamente en qué línea aparece la cadena podemos utilizar -n:

grep -rn "cadena" .

Por ejemplo:

grep -rn "server.port" /etc

Podríamos obtener algo parecido a:

/etc/app/config.conf:15:server.port=8080
/etc/app/server.conf:32:server.port=9090

La salida indica:

archivo:número_de_línea:contenido

Por tanto:

/etc/app/config.conf:15:server.port=8080

significa que la coincidencia está en /etc/app/config.conf, línea 15.

4. Buscar sin distinguir mayúsculas y minúsculas

Por defecto, grep distingue entre mayúsculas y minúsculas.

Por ejemplo:

grep -r "password" .

no necesariamente encontrará:

Password
PASSWORD
PassWord

Para ignorar las diferencias entre mayúsculas y minúsculas utilizamos -i:

grep -rni "password" .

5. Mostrar solamente los nombres de los archivos

En ocasiones no nos interesa saber qué línea contiene la cadena, sino simplemente qué archivos contienen la cadena.

Para ello utilizamos -l:

grep -rl "cadena" .

Ejemplo:

grep -rl "server.port" /etc

Resultado:

/etc/app/application.conf
/etc/app/server.conf
/etc/servicio/config.ini

Esta opción es especialmente útil cuando hay muchos resultados.

6. Buscar una cadena exacta

grep utiliza expresiones regulares por defecto. Si queremos buscar una cadena literalmente, podemos utilizar -F:

grep -rFn "cadena.exacta" .

Por ejemplo:

grep -rFn "192.168.1.100" /etc

Con -F, la cadena se interpreta como texto literal y no como una expresión regular.

7. Buscar solamente en determinados tipos de archivo

Podemos limitar la búsqueda mediante --include.

Por ejemplo, para buscar solamente dentro de archivos .conf:

grep -rn --include="*.conf" "localhost" /etc

Para archivos .txt:

grep -rn --include="*.txt" "palabra" /home

Para varios tipos de archivo:

grep -rn \
  --include="*.conf" \
  --include="*.ini" \
  --include="*.cfg" \
  "localhost" /etc

grep permite utilizar --include para restringir la búsqueda a determinados nombres de archivo.

8. Excluir determinados directorios

Cuando buscamos en un árbol de directorios grande, puede interesarnos evitar determinadas carpetas.

Por ejemplo:

grep -rn --exclude-dir=".git" "cadena" .

Podemos excluir varias:

grep -rn \
  --exclude-dir=".git" \
  --exclude-dir="node_modules" \
  --exclude-dir="cache" \
  "cadena" .

La opción --exclude-dir permite excluir directorios de las búsquedas recursivas.

9. Buscar en todo el sistema Linux

Si no sabemos dónde se encuentra el archivo y queremos buscar en todo el sistema:

sudo grep -Rni "cadena" /

Por ejemplo:

sudo grep -Rni "192.168.1.100" /

Sin embargo, buscar directamente desde / puede generar muchos resultados y errores de permisos.

Es preferible excluir directorios virtuales del sistema:

sudo grep -Rni \
  --exclude-dir=proc \
  --exclude-dir=sys \
  --exclude-dir=dev \
  --exclude-dir=run \
  "cadena" /

También podemos utilizar -s para ocultar los mensajes de error:

sudo grep -Rnis \
  --exclude-dir=proc \
  --exclude-dir=sys \
  --exclude-dir=dev \
  --exclude-dir=run \
  "cadena" /

La opción -s evita que grep muestre determinados mensajes de error, como problemas al acceder a archivos.

10. El problema de que aparezca el historial

Un error bastante común es pensar que grep está buscando dentro de los archivos cuando en realidad se está utilizando sobre la salida del comando history.

Por ejemplo:

history | grep "cadena"

Este comando NO busca dentro de los archivos.

Lo que hace es buscar la cadena dentro de la salida del comando history, es decir, dentro del historial de comandos ejecutados en la terminal.

Por ejemplo:

history | grep ssh

puede devolver:

125  ssh root@192.168.1.10
134  ssh usuario@servidor
145  history | grep ssh

Esto no tiene nada que ver con buscar ssh dentro del contenido de los archivos.

11. La diferencia fundamental

Hay que distinguir entre estas dos situaciones.

Buscar en el historial

history | grep "cadena"

Busca en:

historial de comandos

Buscar dentro de archivos

grep -Rni "cadena" .

Busca en:

contenido de los archivos

Esta diferencia es fundamental.

Si lo que queremos es encontrar una cadena dentro de ficheros, normalmente debemos utilizar:

grep -Rni "cadena" /ruta

12. Ejemplo práctico

Supongamos que tenemos esta estructura:

/opt/servidor/
├── config/
│   ├── server.conf
│   └── database.conf
├── scripts/
│   ├── backup.sh
│   └── start.sh
└── logs/
    └── servidor.log

Queremos localizar dónde aparece:

192.168.1.50

Ejecutamos:

grep -Rni "192.168.1.50" /opt/servidor

Podríamos obtener:

/opt/servidor/config/server.conf:12:server_ip=192.168.1.50
/opt/servidor/scripts/backup.sh:25:SERVER="192.168.1.50"
/opt/servidor/logs/servidor.log:183:Connected to 192.168.1.50

Así sabemos exactamente:

• qué archivo contiene la cadena;
• en qué línea aparece;
• y cuál es el contenido de esa línea.

13. Buscar solamente en archivos de configuración

Si sabemos que la cadena debe estar en archivos .conf:

grep -Rni --include="*.conf" "192.168.1.50" /etc

También podemos buscar en .conf, .ini y .cfg:

grep -Rni \
  --include="*.conf" \
  --include="*.ini" \
  --include="*.cfg" \
  "192.168.1.50" /etc

Esto reduce considerablemente el número de archivos que grep tiene que analizar.

14. Evitar archivos binarios

Cuando buscamos en una gran cantidad de archivos podemos encontrarnos con archivos binarios.

Podemos utilizar -I:

grep -rniI "cadena" /ruta

La opción -I hace que los archivos binarios sean tratados como si no contuvieran coincidencias.

Una búsqueda bastante práctica para archivos de texto sería:

grep -rniI "cadena" /ruta

15. Buscar una palabra completa

Si queremos encontrar solamente una palabra completa podemos utilizar -w.

Por ejemplo:

grep -rnw "root" /etc

Esto busca root como palabra, evitando coincidencias como:

rootuser
myroot
root_password

dependiendo de los límites de palabra reconocidos por grep.

16. Mostrar contexto alrededor de la coincidencia

En ocasiones no basta con ver una única línea.

Podemos mostrar líneas anteriores y posteriores.

Por ejemplo, tres líneas antes y después:

grep -rn -C 3 "cadena" /ruta

También podemos utilizar:

grep -rn -B 3 "cadena" /ruta

para mostrar tres líneas antes.

Y:

grep -rn -A 3 "cadena" /ruta

para mostrar tres líneas después.

Esto resulta muy útil al analizar archivos de configuración.

17. Buscar expresiones más complejas

grep también permite utilizar expresiones regulares.

Por ejemplo:

grep -rnE "192\.168\.1\.[0-9]+" /etc

La opción -E activa las expresiones regulares extendidas.

Esto permite realizar búsquedas más avanzadas que una simple cadena de texto.

18. La opción -r frente a -R

Aunque normalmente veremos:

grep -r

también existe:

grep -R

La diferencia importante está relacionada con los enlaces simbólicos.

-r realiza la búsqueda recursiva y no sigue los enlaces simbólicos encontrados durante el recorrido.

-R realiza la búsqueda recursiva siguiendo los enlaces simbólicos.

Para la mayoría de búsquedas normales:

grep -rn "cadena" /ruta

es suficiente.

19. Comando recomendado para el uso diario

Para la mayoría de situaciones en administración Linux, una de las combinaciones más útiles es:

grep -RniI "cadena" /ruta

Por ejemplo:

grep -RniI "database" /etc

Significado:

-R   búsqueda recursiva
-n   mostrar número de línea
-i   ignorar mayúsculas/minúsculas
-I   ignorar archivos binarios

20. Si solo queremos saber qué archivos contienen la cadena

Utilizaremos:

grep -RliI "cadena" /ruta

Por ejemplo:

grep -RliI "database" /etc

Esto devuelve únicamente los archivos que contienen la cadena.

21. Resumen de los comandos más útiles

Conclusión

Si lo que necesitamos es buscar una cadena de texto dentro del contenido de todos los archivos, el comando fundamental que debemos recordar es:

grep -RniI "cadena" /ruta

Por ejemplo:

grep -RniI "192.168.1.100" /etc

Este comando recorrerá recursivamente /etc, buscará la cadena dentro de los archivos, ignorará las diferencias entre mayúsculas y minúsculas, evitará mostrar archivos binarios y mostrará el número de línea donde se encuentra la coincidencia.

Y hay que tener muy presente la diferencia:

history | grep "cadena"

busca en el historial de comandos, mientras que:

grep -RniI "cadena" /ruta

busca dentro del contenido de los archivos.

Para búsquedas habituales en servidores Linux, grep sigue siendo una de las herramientas más importantes para localizar rápidamente configuraciones, parámetros, direcciones, variables y cualquier otro texto almacenado dentro de los ficheros.

Juan José Fernández Durán

Arquitecto de Soluciones & Consultor IT

See author's posts