El comando base64 permite codificar y descodificar cadenas de caracteres desde línea de comandos GNU/Linux, en este caso desde BASH.

Para codificar el contenido de un fichero utilizaremos la siguiente sintaxis, utilizaremos el fichero test.txt que contiene la cadena “esto es una prueba”:

$ base64 test.txt
ZXN0byBlcyB1bmEgcHJ1ZWJhCg==

Para descodificarlo utilizamos la siguiente sintaxis, en este caso el fichero de texto contiene la cadena encriptada “ZXN0byBlcyB1bmEgcHJ1ZWJhCg==”:

$ base64 -d test.txt
esto es una prueba

Si queremos codificar o descodificar directamente la cadena de texto, la mandamos a salida estandar y luego la codificamos/descodificamos:

$ echo "esto es una prueba" | base64
ZXN0byBlcyB1bmEgcHJ1ZWJhCg==

$ echo "ZXN0byBlcyB1bmEgcHJ1ZWJhCg==" | base64 -d
esto es una prueba

Los comandos cat, more y less permiten mostrar el contenido de ficheros de texto desde la línea de comandos en sistemas Unix, las principales características y diferencias de cada uno de ellos son las siguientes:

Comando Unix CAT

El comando ‘cat’ imprimirá por pantalla el contenido del fichero sin ningún tipo de paginación ni posibilidad de modificarlo. Básicamente concatena archivos o la salida estándar en la salida estándar. Podemos pasarle parámetros como:

  -A, --show-all           lo mismo que -vET
  -b, --number-nonblank    numera las líneas que no están vacías
  -e                       lo mismo que -vE
  -E, --show-ends          muestra un $ al final de cada línea
  -n, --number             numera todas las líneas
  -s, --squeeze-blank      nunca muestra más de una línea vacía,
  -t                       equivalente a -vT
  -T, --show-tabs          muestra los caracteres de tabulación como ^I
  -u                       (sin efecto)
  -v, --show-nonprinting   utiliza la notación ^ y M-, salvo para LFD y TAB
      --help     muestra esta ayuda y finaliza
      --version  informa de la versión y finaliza

Mostrar el contenido de un fichero:

$ cat fichero

Concatenar dos ficheros de texto en uno:

$ cat fichero1 fichero2 > fichero3

Comando Unix MORE

Al igual que ‘cat’, ‘more’ permite visualizar por pantalla el contenido de un fichero de texto, con la diferencia con el anterior de que ‘more’ pagina los resultados. Primero mostrará por pantalla todo lo que se pueda visualizar sin hacer scroll y después, pulsando la tecla espacio avanzará de igual modo por el fichero.

$ more fichero
texto de ejemplo
texto de ejemplo
texto de ejemplo
--Más--(23%)

También podemos especificarle el número de líneas a mostrar y otros parámetros:

uso: more [-dflpcsu] [+númlíneas | +/patrón] nombre1 nombre2 ...

Comando Unix LESS

El comando ‘less’ es el más completo de los tres, pues puede hacer todo lo que hace ‘more’ añadiendo mayor capacidad de navegación por el fichero (avanzar y retroceder) además de que sus comandos están basados en el editor ‘vi’, del cual se diferencia en que no tiene que leer todo el contenido del fichero antes de ser abierto. Tiene una gran cantidad de opciones y parámetros, como siempre lo recomendable:

$ less --help

Si tenéis una máquina con más de una CPU, y el comando TOP en lugar de mostrar la información detallada de cada una de ellas la muestra conjunta, debéis hacer lo siguiente:

Ejemplo de comando TOP con las CPU(s) agrupadas:

top - 11:02:08 up 26 min,  2 users,  load average: 0.01, 0.02, 0.03
Tasks: 102 total,   1 running, 141 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  0.0%sy,  0.0%ni, 99.9%id,  0.1%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:  16433556k total,   414260k used, 16019296k free,    25672k buffers
Swap:  2096472k total,        0k used,  2096472k free,   177120k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+a COMMAND
10460 root      15   0 12740 1136  828 R  0.3  0.0   0:00.16 top
    1 root      15   0 10348  704  592 S  0.0  0.0   0:01.26 init [3]

Una vez dentro de la ejecución de top, presionad la tecla 1 para que se desplieguen todas las CPU. Si os agrada el resultado, presionad W para guardar el cambio y que por defecto aparezcan así:

top - 11:04:04 up 28 min,  2 users,  load average: 0.02, 0.02, 0.03
Tasks: 102 total,   1 running, 141 sleeping,   0 stopped,   0 zombie
Cpu0  :  0.2%us,  0.1%sy,  0.1%ni, 98.9%id,  0.5%wa,  0.0%hi,  0.2%si,  0.0%st
Cpu1  :  0.1%us,  0.1%sy,  0.0%ni, 99.8%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu2  :  0.1%us,  0.1%sy,  0.0%ni, 99.8%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu3  :  0.1%us,  0.1%sy,  0.0%ni, 99.8%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu4  :  0.2%us,  0.0%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu5  :  0.1%us,  0.1%sy,  0.0%ni, 99.6%id,  0.1%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu6  :  0.3%us,  0.0%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu7  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:  16433556k total,   413868k used, 16019688k free,    25896k buffers
Swap:  2096472k total,        0k used,  2096472k free,   177288k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
    1 root      15   0 10348  704  592 S  0.0  0.0   0:01.26 init
    2 root      RT  -5     0    0    0 S  0.0  0.0   0:00.01
    3 root      34  19     0    0    0 S  0.0  0.0   0:00.00

El comando crontab nos permite añadir, eliminar o modificar los cron configurados para un usuario de una máquina Unix.

El modo de uso es el siguiente: crontab -<opciones>, a continuación os muestro unos ejemplos:

Editar los cron del usuario “alex”:

crontab -e -u alex

Listar los cron del usuario “alex”:

crontab -l -u alex

Eliminar los cron del usuario alex:

crontab -r -u alex

En todos estos casos, si omitimos “-u alex” accederemos a los cron del usuario con el que estemos identificados en el sistema. Una vez dentro de la gestión de crontab (si estamos editando con -e” visualizaremos todos los cron configurados para el usuario, ejemplo:

Nota: Automáticamente accederéis a la gestión de los cron con el editor que haya configurado por defecto, si queréis modificarlo revisad esta entrada: Cambiar editor crontab por defecto)

$ crontab -e -u alex

0 * * * * /usr/sbin/ntpdate hora.oxixares.com > /dev/null
0 20 * * * echo "Me ejecuto a las ocho en punto" > /dev/null

Crontab pone a nuestra disposición 6 campos cuyo significado es el siguiente (en orden, de izquierda a derecha) :

1. Minuto (0-59)
2. Hora (0-23)
3. Día del mes (1-31)
4. Mes del año (1-12)
5. Día de la semana (0-7, 0 y 7 es Domingo)
6. Comando/Script/tarea a ejecutar

En los 5 primeros campos podemos usar Wildcard (*), para especificar que se ejecutará en cualquiera de las opciones de ese campo (si son horas todas las horas, si son días todos los días, etc).

En el primer ejemplo que he mostrado antes, cada hora en punto ejecutamos la sincronización horaria y mandamos la salida a /dev/null/:

0 * * * * /usr/sbin/ntpdate hora.oxixares.com > /dev/null

En el segundo ejemplo, simplemente escribimos la frase a las 20:00 todos los días:

0 20 * * * echo "Me ejecuto a las ocho en punto" > /dev/null

Al comienzo del fichero podemos especificar una dirección de correo electrónico a la cual se envíen los informes de ejecución de crontabs:

MAILTO="test@test.com"

Con estas nociones básicas ya podéis trabajar de un modo eficaz gestionando cron mediante el comando crontab.

Para apagar o reiniciar una máquina Windows de forma remota, y desde un equipo Linux lo primero que tenemos que hacer es tener instalado el paquete samba-common, que contiene herramientas y ficheros que se utilizan para la comunicación entre el cliente y servidor Samba.

En sistemas Debian lo instalaremos del siguiente modo:

sudo apt-get install samba-common

Y en sistemas RHEL / CentOS:

yum install samba-common

Una vez instalado el paquete, podremos hacer uso del comando “net rpc” (revisad la documentación de net porque tiene muchas más posibilidades) para reiniciar o apagar un servidor Windows de forma remota.

Apagar un servidor Windows desde Linux:

net rpc shutdown -I IP_SERVIDOR_WINDOWS -U usuario%password

Reiniciar un servidor Windows desde Linux:

net rpc shutdown -r IP_SERVIDOR_WINDOWS -U usuario%password

Hay que tener en cuenta que el usuario que utilicéis para realizar estas tareas debe encontrarse dentro del grupo administradores de la máquina Windows. Si tenéis pensado administrar en mayor o menor medida equipos Windows desde Linux os recomiendo revisar todas las demás opciones de net.

Por defecto, rsync no elimina los ficheros antiguos en el servidor de destino de la copia. Esto implica que pese a que haya ficheros en el sistema del que estamos haciendo copias de seguridad que ya han sido eliminados, permanecerán por siempre en el sistema de copias de seguridad (destino) a no ser que los eliminemos manualmente.

Las opciones para forzar que cada vez que ejecutemos rsync también se eliminen en el destino ficheros y carpetas que ya no existen en el origen son las siguientes:

     --del                   an alias for --delete-during
     --delete                delete extraneous files from destination dirs
     --delete-before         receiver deletes before transfer (default)
     --delete-during         receiver deletes during transfer, not before
     --delete-after          receiver deletes after transfer, not before
     --delete-excluded       also delete excluded files from destination dirs
     --ignore-errors         delete even if there are I/O errors
     --force                 force deletion of directories even if not empty
     --max-delete=NUM        don't delete more than NUM files

La opción más básica es –delete, aunque podemos personalizar aún más y elegir si deseamos que los ficheros a borrar se eliminen antes de la transferencia de ficheros (–delete-before, es lo mismo que –delete), después (-delete-after) o durante (–delete-during). Además de esto podemos elegir si ignorar errores y borrar pese a fallos de I/O, forzar eliminación de directorios no vacíos, etc.

Ejemplo de rsync con sincronización y borrado de archivos:


#!/bin/sh

# now the actual transfer
rsync $OPTS $BDIR $BSERVER::$USER/current


Es imposible conocer todos los comandos que nos ofrece cualquier shell, para solucionar este “problema” existen herramientas que nos hacen la vida más fácil, una de ellas es el comando apropos.

Apropos es un comando que busca dentro de las descripciones de cada una de las páginas man las palabras claves que le indiquemos pasandolas como argumentos. Estas palabras claves pueden contener comodines o ser la palabra clave exacta.

Por ejemplo, si quisieramos buscar comandos que sirven para copiar ficheros podríamos hacerlo del siguiente modo (suponiendo un sistema en idioma inglés):

$ apropos "copy files"
cp (1)               - copy files and directories
cpio (1)             - copy files to and from archives
install (1)          - copy files and set attributes

Como véis nos muestra tres comandos que pueden servirnos para realizar operaciones de copiado de ficheros. Otro ejemplo podría ser la búsqueda de un comando/programa para gestionar particiones:

$ apropos "partition"
addpart (8)          - simple wrapper around the "add partition" ioctl
cfdisk (8)           - Curses/slang based disk partition table manipulator for Linux
delpart (8)          - simple wrapper around the "del partition" ioctl
fdisk (8)            - Partition table manipulator for Linux
iostat (1)           - Report Central Processing Unit (CPU) statistics and input/output statistics for devices, partitions an...
mpartition (1)       - partition an MSDOS hard disk
partprobe (8)        - inform the OS of partition table changes
partx (8)            - telling the kernel about presence and numbering of on-disk partitions.
sfdisk (8)           - Partition table manipulator for Linux

Como véis es un comando muy útil en situaciones que no conocemos un comando para realizar una determinada tarea.

Con estas dos secuencias de comandos podréis ver de un modo rápido y sencillo los procesos ordenados por uso (%) de CPU y memoria. Por supuesto no es necesario (ni práctico) escribir el comando completo en la shell cada vez que lo queráis ejecutar, os recomiendo crear un alias específico para cada uno de ellos.

Listar procesos por % cpu, veréis que eliminamos aquellos que usan 0.0 de CPU con sed (sed ‘/^ 0.0 /d):

ps -e -o pcpu,cpu,nice,state,cputime,args --sort pcpu | sed '/^ 0.0 /d'

Ejemplo:

$ ps -e -o pcpu,cpu,nice,state,cputime,args --sort pcpu | sed '/^ 0.0 /d'
%CPU CPU  NI S     TIME COMMAND
0.2   -   0 S 00:00:24 metacity
0.2   -   0 S 00:00:00 /usr/bin/python /usr/bin/terminator
0.2   -   0 S 00:00:28 gnome-screensaver
0.2   -   0 S 00:00:31 gnome-panel
4.6   -   0 S 00:08:23 /usr/bin/pulseaudio --start
7.4   -   0 S 00:13:24 /usr/X11R6/bin/X :0 -br -audit 0 -auth /var/lib/gdm/:0.Xauth -nolisten tcp vt7
7.5   -   0 S 00:04:31 rhythmbox
14.4   -   0 S 00:08:50 /usr/lib/firefox-3.5.4/firefox-3.5

Listar procesos por uso de memoria (en KB):

ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS

Ejemplo (reducido):

$ ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS
23964 gnome-panel
26168 nautilus
26256 /usr/bin/python /usr/bin/terminator
58340 /usr/X11R6/bin/X :0 -br -audit 0 -auth /var/lib/gdm/:0.Xauth -nolisten tcp vt7
58728 rhythmbox
128736 /usr/lib/firefox-3.5.4/firefox-3.5

Encontrado en pixelbeat