Mientras que te fortalece en tu rol actual, aprender Linux también te puede ayudar en transicionar a otras carreras tech como DevOps, Ciberseguridad, y Computación en la Nube.

En este manual, aprenderás las bases de la línea de comandos de Linux, y luego transitaremos a temas más avanzados como programación de scripts y administración de sistema. Sea que eres nuevo en Linux o que ya has estado usándolo por años, este libro tiene algo para ti.

Nota Importante: Todos los ejemplos en este libro son mostrados en Ubuntu 22.04.2 LTS (Jammy Jellyfish). La mayoría de las herramientas de línea de comandos son más o menos los mismos en otras distribuciones. Sin embargo, algunas aplicaciones de escritorio (GUI) y comandos podrían diferir si estás trabajando en otra distribución de Linux.

Tabla de Contenidos

Parte 1: Introducción a Linux

• 1.1. Comenzando con Linux

Parte 2: Introducción al Shell de Bash y los Comandos de Sistema

• 2.1. Comenzando con el shell de Bash
• 2.2. La Estructura de Command
• 2.3. Comandos de Bash y Atajos de Teclado
• 2.4. Identificándote: El Comando whoami

Parte 3: Entendiendo tu Sistema de Linux

• 3.1. Descubriendo tu SO y Especificaciones

Parte 4: Manejando Archivos desde la Línea de Comando

• 4.1. La Jerarquía del Sistema de Archivos de Linux
• 4.2. Navegando a través del Sistema de Archivos de Linux
• 4.3. Manejando Archivos y Directorios
• 4.4 Localizando archivos y carpetas usando el comando find
• 4.5. Comandos Básicos para ver Archivos

Parte 5: Lo Esencial sobre Edición de Texto en Linux

• 5.1. Dominando Vim: La Guía Completa
• 5.2. Dominando Nano

Parte 6: La Programación en Bash

• 6.1. Definición de los scripts de Bash
• 6.2. Ventajas de los scripts de Bash
• 6.3. Vista General del Shell Bash y de la Interfaz de Línea de Comandos
• 6.4. Cómo crear y ejecutar scripts de Bash
• 6.5. Lo Básico de la Programación en Bash

Parte 7: Manejando Paquetes de Software en Linux

• 7.1. Paquetes y Gestión de Paquetes
• 7.2. Instalando un Paquete a través de la Línea de Comando
• 7.3. Instalando un Paquete a través de un Método Gráfico Avanzado – Synaptic
• 7.4. Instalando Paquetes Descargados desde un sitio web

Parte 8: Temas de Linux Avanazados

• 8.1. Gestión del Usuario
• 8.2 Conectándose a Servidores Remotos a través de SSH
• 8.3. Análisis Sintáctico y Análisis de Archivos Log Avanzados
• 8.4. Manejando los Procesos de Linux a través de la Línea de Comandos
• 8.5. Flujos de Entrada y Salida Estándar en Linux
• 8.6 Automatización en Linux – Automatizar Tareas con Tareas de Cron
• 8.7. Conceptos Básicos de Redes de Linux
• 8.8. Solución de problemas de Linux: Herramientas y Técnicas
• 8.9. Estrategia de Solución de Problemas General para los Servidores

Conclusión

Parte 1: Introducción a Linux

1.1. Comenzando con Linux

¿Qué es Linux?

Linux es un Sistema Operativo de código abierto que está basado en el Sistema Operativo Unix. Fue creado por Linus Torvalds in 1991.

El Código Abierto significa que el código fuente del Sistema Operativo está disponible al público. Este le permite a cualquiera modificar el código origina, personalizarlo, y distribuir el Sistema Operativo a usuarios potenciales.

¿Por qué deberías aprender sobre Linux?

En el escenario de los centros de datos de hoy, Linux y Microsoft Windows se destacan como los contendientes, con Linux teniendo la mayor parte.

Aquí hay varias razones convincentes para aprender Linux:

• Dada la prevalencia del alojamiento de Linux, hay una alta chance que tu aplicación será alojado en Linux. Así que aprender Linux como un desarrollador se convierte cada vez más valorado.
• Con la computación en la nube se convierte en la norma, las chances son altas que tus instancias de la nube se basará en Linux.
• Los servidores de Linux como la fundación para muchos Sistemas Operativos para el Internet de las Cosas (IoT) y aplicaciones móviles.
• En IT, hay muchas oportunidades para aquellos hábiles en Linux.

¿Qué significa que Linux es un Sistema Operativo de código abierto?

Primero, ¿qué es código abierto? Software de código abierto cuyo código fuente es accesible gratuitamente, permitiendo a cualquier utilizar, modificar y distribuirlo.

Cuando sea que el código fuente fuese creado, se considera automáticamente protegido por derechos de autor, y su distribución se rige por el titular de los derechos de autor a través de licencias de software.

En contraste al código abierto, el software propietario o de código cerrado restringe el acceso a su código fuente. Solamente los creadores pueden verlos, modificarlos o distribuirlos.

Linux es ante todo de código abierto, lo que significa que su código fuente está disponible de forma gratuita. Cualquiera puede verlo, modificarlo, y distribuirlo. Los Desarrolladores desde cualquier lugar en el mundo pueden contribuir a sus mejoras. Esto sienta la fundación de la colaboración lo cual es un aspecto importante del software de código abierto.

Esto enfoque colaborativo ha llevado a la amplia adopción de Linux entre los servidores, computadoras de escritorio, sistemas embebidos, y dispositivos móviles.

El aspecto más interesante de Linux siendo de código abierto es que cualquier puede adaptar el sistema operativo a sus necesidades específicas sin ser restringido por las limitaciones de propiedad.

El SO (Sistema Operativo) Chrome utilizado por los Chromebooks está basado en Linux. Android, que impulsa a muchos teléfonos inteligentes, también está basado en Linux.

¿Qué es un Kernel de Linux?

El kernel es el componente central de un Sistema Operativo que gestiona la computadora y sus operaciones hardware. Maneja operaciones de memoria y el tiempo de CPU.

El kernel actúa como un puente entre aplicaciones y el proceso de datos a nivel de hardware usando la comunicación entre procesos y llamadas de sistema.

El kernel se carga en memoria primero cuando un Sistema Operativo comienza y permanece allí hasta que el sistema se apaga. Es responsable de tareas como la gestión de disco, gestión de tareas, y gestión de memoria.

Si estás interesado en saber cómo se ve el kernel de Linux, aquí está el enlace de Github.

¿Que es una distribución de Linux?

A este punto, sabes que puedes re-usar el código kernel de Linux, modificarlo, y crear un nuevo kernel. Puedes aún combinar diferentes utilidades y software para crear un Sistema Operativo completamente nuevo.

Una distribución de Linux o distro es una versión del Sistema Operativo Linux que incluye el kernel de Linux, utilidades de sistema, y otros software. Siendo de código abierto, una distribución de Linux es un esfuerzo colaborativo que involucra múltiples comunidades de desarrollo de código abierto independientes.¿Qué significa que una distribución sea derivado? Cuando dices que una distribución es "derivado" de otro, el nuevo distro está construido sobre la base o fundación del distro original. Esta derivación puede incluir el usar el sistema de gestión de paquetes (más sobre esto después), versión del kernel, y a veces las mismas herramientas de configuración.

Hoy, hay miles distribuciones de Linux para elegir, ofreciendo diferentes objetivos y criterios para seleccionar y soportar el software provisto por su distribución.

Las distribuciones varían uno del otro, pero generalmente tienen características en común.

• Una distribución consiste de un kernel de Linux.
• Soporta programas de espacio de usuario.
• Una distribución podría ser pequeño y de un solo propósito o incluir miles de programas de código abierto.
• Algunos medios para instalar y actualizar la distribución y sus componentes debería ser provistos.

Si ves la Línea de Tiempo de las Distribuciones de Linux, verás dos mayores distros: Slackware y Debian. Varias distribuciones son derivados de ellos. Por ejemplo, Ubuntu y Kali son derivados de Debian.

¿Cuáles son las ventajas de la derivación? Hay varias ventajas de la derivación. La Distribuciones derivadas pueden aprovechar la estabilidad, seguridad, y grandes repositorios de software de la distribución padre.

Cuando se construye sobre una fundación existente, los desarrolladores pueden conducir su enfoque y esfuerzo enteramente en las características especializadas de la nueva distribución. Los usuarios de distribuciones derivadas se pueden beneficiar de la documentación, el soporte de comunidad, y recursos ya disponibles para la distribución padre.

Algunas distribuciones de Linux populares son:

1. Ubuntu: Uno de las distribuciones de Linux más usado y más popular. Es amigable y recomendado para los principiantes. Aprender más sobre Ubuntu aquí.
2. Linux Mint: Basado en Ubuntu, Linux Mint provee una experiencia amigable con un enfoque en soporte de multimedia. Aprender más sobre Linux Mint aquí.
3. Arch Linux: Popular entre usuarios experimentados, Arch es una distribución ligera y flexible dirigido a usuarios que prefieren un enfoque DIY. Aprender más sobre Arch Linux aquí.
4. Manjaro: Basado en Arch Linux, Manjaro provee una experiencia amigable con software pre-instalado y herramientas sencillas de gestión del sistema. Aprender más sobre Manjaro aquí.
5. Kali Linux: Kali Linux provee un conjunto comprensivo de herramientas de seguridad y está mayormente enfocado en ciberseguridad y hacking. Aprender más sobre Kali Linux aquí.

Cómo instalar y acceder a Linux

La mejor manera de aprender es aplicar los conceptos a medidas que avanzas. En esta sección, aprenderemos cómo instalar Linux en tu máquina así puedes seguirme. También aprenderás cómo acceder a Linux en una máquina con Windows.

Te recomiendo que sigas cualquiera de los métodos mencionados en esta sección para tener acceso a Linux así puedes seguirme.

Instalar Linux como el SO primario

Instalar Linux como el SO primario es la forma más eficiente de usar Linux, ya que puedes usar todo el poder de tu máquina.

En esta sección, aprenderás cómo instalar Ubuntu, el cual es uno de las distribuciones de Linux más popular. Dejé fuera de lista otras distribuciones por ahora, ya que quiero mantener las cosas sencillas. Siempre puedes explorar otras distribuciones una vez que te sientas cómodo con Ubuntu.

Paso 1 – Descargar el iso de Ubuntu: Ve al sitio web oficial y descarga el archivo iso. Asegúrate en seleccionar un lanzamiento estable que está caracterizado como "LTS". LTS significa "Soporte de Largo Término" (Long Term Support en inglés) lo que significa que puedes obtener seguridad gratuita y actualizaciones de mantenimiento por un tiempo prolongado (usualmente 5 años).

Paso 2 – Crea un pendrive bootable: Hay un número de softwares que puede crear un pendrive booteable. Recomiendo usar Rufus, ya que es bastante fácil de usar. Puedes descargarlo aquí.

Paso 3 – Iniciar desde el pendrive: Una vez que tu pendrive bootable está listo, insértalo y inicia desde el pendrive. El menú del boot depende de tu laptop. Puedes buscar en google el menú de boot para tu modelo de laptop.

Paso 4 – Sigue los pasos. Una vez, que el proceso de boot comience, selecciona try or install ubuntu.

El proceso tomará algo de tiempo. Una vez que el GUI aparece, puedes seleccionar el idioma, y el teclado, y continuar. Ingresa al inicio de sesión con tu nombre. Recuerda las credenciales ya que los necesitarás para inciar sesión en tu sistema y acceder a privilegios totales. Espera que la instalación se complete.

Paso 5 – Reinicia: Haz clic en reiniciar ahora y retira el pen drive.

Paso 6 – Inicia sesión: Inicia sesión con las credenciales que ingresaste anterioremente.

¡Y ahí está! Ahora puedes instalar aplicaciones y personalizar tu escritorio.

Para una instalación avanzada, puedes explorar los siguientes temas:

• Particionamiento de Disco.
• Configurar la memoria de intercambio para permitir la hibernación.

Accediendo a la terminal

Una parte importante de este manual es aprender sobre la terminal donde ejecutarás todos los comandos y ver toda la magia. Puedes buscar en la terminal presionando la tecla "window" y escribiendo "terminal". Puedes fijar la Terminal en el dock donde otras aplicaciones están localizadas para un fácil acceso.

💡 The shortcut for opening the terminal is ctrl+alt+t

También puedes abrir la terminal desde una carpeta. Haz clic derecho donde estás y haz clic en "Abrir en Terminal". Esto abrirá la terminal en la misma ruta.

Cómo usar Linux en una máquina Windows

A veces prodrías necesitar ejecutar tanto Linux como Windows lado a lado. Afortunadamente, hay varias maneras que puedes aprovechar de ambos mundos sin tener distintas computadoras para cada sistema operativo.

En esta sección, explorarás una pocas formas de usar Linux en una máquina de Linux. Algunos de ellos basados al navegador o basados en la nube y no necesita ninguna instalación de SO antes de usarlos.

Opción 1: "Dual-boot" Linux + Windows: Con dual boot, puedes instalar Linux juntamente con Windows en tu computadora, permitiéndote elegir qué Sistema Operativo usar al inicio.

Esto requierer particionar tu disco duro e instalar Linux en una partición separada. Con este enfoque, solamente puedes usar un sistema Operativo a la vez.

Opción 2: USar el Subsitema de Windows  para Linux  (WSL): El Subsistema para Linux provee una capa de comtabilidad que te permite ejecutar ejecutables binarios de Linux de forma nativa en WIndows.

Usando WSL tiene algunas ventajas. La configuración para WSL es sencilla y rápida. Es liviana comparado con los VMs donde tiene que aisgnar recursos desde la máquina anfitriona. No necesitas instalar ningún ISO o imagen de disco virtual para las máquinas Linux los cuales tienden a ser archivos pesados. Puedes usar Windows y Linux lado a lado.

Cómo instalar WSL2

Primero, activa el Subsitema de Windows para la opción Linux en las configuraciones.

Ve al inicio. Busca "Turn Windows features on or off".

Verifica la opción "Windows Subsystem for Linux" si ya no está.

Luego, abre tu línea de comandos y provee los comandos de instalación.

Abre la terminal como un administrador:

Ejecuta el comando de abajo:

wsl --install

Esta es la salida:

Nota: Por defecto, Ubuntu será instalado.

• Una vez que la instalación está completa, necesitarás reiniciar tu máquina WIndows. Así que, reinicia tu máquina con Windows.

Después de reiniciar, verías una ventana así:

Una vez que la instalación de Ubuntu está completa, se te pedirá que ingreses tu nombre de usuario y la constraseña.

Y, ¡y eso es todo! Estás listo ya para usar Ubuntu.

Lanza Ubuntu buscando desde el menú de inicio.

Y aquí tenemos tu instancia de Ubuntu lanzada.

Opción 3: Usa a Máquina Virtual (VM)

Una máquina virtual (VM) es una emulación de software de un sistema de computación de Física. Te permite ejeuctar múltiples Sistemas Operativos y aplicaciones en una sola máquina física simultáneamente.

Puedes usar la Virtualización de Software tales como VirtualBox de Oracle o VMware para crear una máquina virtual que ejecuta Linux dentro de tu entorno de Windows. Esto te permite ejecutar Linux como un SIstema Operativo invitado junto a Windows.

El software VM provee opciones para asignar y gestionar los recursos hardware para cada VM, incluyendo núcles de CPU, memoria, espacio de disco, y ancho de banda de red. Puedes ajustar estas asignaciones basado en los requerimientos de los Sistemas Operativos invitados y las aplicaciones.

Aquí hay algunas de las opciones comúnes disponibles para la Virtualización:

• Oracle virtual box
• Multipass
• VMware workstation player

Opción 4: Usa una Solución basado en el Navegador

Las soluciones basados en el Navegador son particularmente útiles para pruebas rápidas, aprender, o acceder a entornos de Linux desde dispositivos que no tienen Linux instalado.

Puedes usar los editores de código en líne o terminales basadas en web para acceder a Linux. Fíjate que usualmente no tienes privilegios de administrador en estos casos.

Editores de Código en línea

Los Editores de Código en línea con terminales de Linux incorporadas. Mientras que su propósito primario es codificar, también puedes utilizar la terminal de Linux para ejecutar comandos y realizar tareas.

Replit es un ejemplo de un editor de código en línea, donde puedes escribir tu código y acceder a la shell de Linux al mismo tiempo.

Terminales de Linux basados en Web

Las terminales de Linux en línea te permiten acceder a una interfaz de línea de comandos desde tu navegador. Estas terminalesproveen una interfaz basada en web a un shell de Linux, permitiéndote ejecutar comandos y trabajar con utilidades de Linux.

Un ejemploes JSLinux. La captura de abajo muestra un entorno de Linux listo para ser usado:

Opción 5: Usa una Solución basada en la Nube

En vez de ejecutar Linux directamente en tu máquina de Windows, puedes considerar usar entornos de Linux basados en la nube o Servidores Privados Virtuales (VPS), para acceder y trabajar con Linux remotamente.

Servicios como Amazon EC2, Microsoft Azure, o DigitalOcean proveen instancias de Linux a las que te puedes conectar desde tu computadora de Windows. Fíjate que algunos de estos servicios ofrecen planes gratuitos, pero no son usualmente gratis a la larga.

Parte 2: Introducción al Shell de Bash y Comandos de Sistema

2.1. Comenzando con el shell de Bash

Introducción al shell de bash

La línea de comandos de Linux es provisto por un programa llamado el shell. A través de los años, el programa shell ha evolucinado para atender varias opciones.

Distintos usuarios pueden ser configurados para usar distintos shells. Pero, la mayoría de los usuarios prefieren quedarse con su shell predeterminado actual. El shell predeterminado para muchos distros de Linux es el Bourne-Again Shell de GNU (bash). Bash es sucedido por el shell Bourne (sh).

Para saber tu shell actual, abre tu terminal e ingresa el siguiente comando:

echo $SHELL

Desglose del comando:

• El comando echo se usa para imprimir en la terminal.
• El $SHELL es una variable especial que contiene el nombre del shell actual.

En mi configuración, la salida es /bin/bash. Esto significa que estoy usando el shell bash.

# output
echo $SHELL
/bin/bash

Bash es muy poderoso ya que puede simplificar ciertas operaciones que son difíciles de lograr eficientemente con un GUI (o Interfaz de Usuario Gráfico). Recuerda que la mayoría de los servidores no tienen un GUI, y es mejor aprender a usar los poderosos de una interfza de línea de comandos (CLI).

Terminal vs Shell

Los términos "terminal" y "shell" son frecuentemente usado de forma intercambiable, pero se refieren a distitnas partes de la interfaz de línea de comandos.

La terminal es la interfaz que usas para interactuar con el shell. El shell es el intérprete de comandos que procesa y ejecuta tus comandos. Aprenderás más sobre los shells en la Parte 6 del manual.

¿Qué es un prompt?

Cuando un shell se usa interactivamente, muestra un $ cuando espera un comando del usuario. Este es el prompt del shell.

[username@host ~]$

Si el shell se está ejecutando como root (aprenderás más sobre el usuario root luego), el prompt se cambia a #.

[root@host ~]#

2.2. Estructura del Comando

Un comando es un programa que ejecuta una operación específica. Una vez que tienes acceso a la shell, puedes ingresar cualquier comando después del signo $ y ves la salida en la terminal.

Generalmente, los comandos de Linux sigue esta sintaxis:

command [options] [arguments]

Aquí está el desglose de la sintaxis de arriba:

• command: Este es el nombre del comando que quieres ejecutar. ls (list - listar), cp (copy - copiar), y rm (remove - borrar) son comandos comúnes de Linux.
• [options]: Opciones, o flags, son precedidos frecuentemente por un guión (-) o doble guiones (--), modifican el comportamiento del comando. Pueden cambiar cómo opera el comando. Por ejemplo, ls -a usa la opción -a para mostrar los archivos ocultos en la carpeta actual.
• [arguments]: Los argumentos son las entradas para los comandos que uno requiere. Estos pueden ser nombres de archivos, nombres de usuario, u otros datos sobre los cuales el comando actuará. Por ejemplo, en el comando cat access.log, cat es el comando y access.log es la entrada. Como resultado, el comando cat muestra los contenidos del archivo access.log.

Las opciones y argumentos no son requeridos por todos los comandos. Algunos comandos pueden ser ejecutados sin ninguna opción o argumento, mientras que otros podrían requerir uno o ambos para que funcionen correctamente. Siempre puedes referirte al manual del comando para ver las opciones y los argumentos que soporta.

💡Consejo: Puedes ver el manual de un comando usando el comando man.

Puedes acceder a la página manual para ls con man ls, y te mostrará algo así:

Las páginas manuales son una forma genial y rápida para acceder a la documentación. Recomiendo leer las páginas de man para los comandos que mas usas.

2.3. Comandos de Bash y Atajos de Teclado

Cuando estás en la terminal, puedes acelerar tus tareas usando atajos.

Aquí hay algunos de los atajos más comunes de la terminal:

2.4. Identificándote: El comando whoami

Puedes obtener el nombre de usuario con el que iniciaste sesión con el comando whoami. Este comando es útil cuando cambias entre distintos usuarios y quieres confirmar el usuario actual.

Justo después del signo $, escribe whoami y presiona enter.

whoami

Esta es la salida que obtuve.

zaira@zaira-ThinkPad:~$ whoami
zaira

Parte 3: Entendiendo tu Sistema de Linux

3.1. Descubriendo tu SO y Especificaciones

Imprimir información del sistema usando el comando uname

Puedes obtener información del sistema de forma detallada del comando uname.

Cuando provees la opción -a, imprime toda la información del sistema.

uname -a
# salida
Linux zaira 6.5.0-21-generic #21~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Feb  9 13:32:52 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

En la salida de arriba,

• Linux: Indica el sistema operativo.
• zaira: Representa el nombre del host de la máquina.
• 6.5.0-21-generic #21~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Feb 9 13:32:52 UTC 2: Provee información sobre la versión del kernel, fecha de la construcción, y algunos detalles adicionales.
• x86_64 x86_64 x86_64: Indica la arquitectura del sistema.
• GNU/Linux: Representa el tipo de sistema operativo.

Encontrar detalles de la arquitectura de la CPU usando el comando lscpu

El comando lscpu en Linux se usa para mostrar información sobre la arquitectura de la CPU. Cuando ejecutas lscpu en la terminal, provee detalles tales como:

• La arquitectura de la CPU (por ejemplo, x86_64)
• op-mode(s) de la CPU (por ejemplo, 32-bit, 64-bit)
• Orden de Byte (por ejemplo, Little Endian)
• CPU(s) (número de CPUs), y así sucesivamente

Intentémoslo:

lscpu
# salida
Architecture:            x86_64
  CPU op-mode(s):        32-bit, 64-bit
  Address sizes:         48 bits physical, 48 bits virtual
  Byte Order:            Little Endian
CPU(s):                  12
  On-line CPU(s) list:   0-11
Vendor ID:               AuthenticAMD
  Model name:            AMD Ryzen 5 5500U with Radeon Graphics
    Thread(s) per core:  2
    Core(s) per socket:  6
    Socket(s):           1
    Stepping:            1
    CPU max MHz:         4056.0000
    CPU min MHz:         400.0000

Eso fue mucha información, ¡pero útil también! Recuerda que siempre puedes ir viendo información relevante usando argumentos específicos. Ve el manual del comando con man lscpu.

Parte 4: Manejando archivos desde la Línea de Comandos

4.1. La Jerarquía del sistema de archivos de Linux

Todos los archivos en Linux son almacenados en un sistema de archivos. Sigue una estructura tipo árbol invertido porque la raíz está en la parte superior.

El  / es la carpeta raíz y el punto de comienzo del sistema de archivos. La carpeta raíz contiene todas las otras carpetas y archivos en el sistema. El caracter / también sirve como una carpeta separadora entre los nombres de rutas. Por ejemplo, /home/alice forma una ruta completa.

La imagen de abajo muestra la jerarquía completa del sistema de archivos. Cada carpeta sirve un propósito específico.

Fíjate que esta no es una lista exhaustiva y distintas distribuciones podría tener distintas configuraciones.

Aquí hay una tabla que muestra el propósito de cada carpeta:

💡 Consejo: Puedes aprender más sobre el sistema de archivos usando el comando man hier.

Puedes ver tu sistema de archivos usando el comando tree -d -L 1. Puedes modificar el argumento -L para cambiar la profundidad del árbol.

tree -d -L 1
# salida
.
├── bin -> usr/bin
├── boot
├── cdrom
├── data
├── dev
├── etc
├── home
├── lib -> usr/lib
├── lib32 -> usr/lib32
├── lib64 -> usr/lib64
├── libx32 -> usr/libx32
├── lost+found
├── media
├── mnt
├── opt
├── proc
├── root
├── run
├── sbin -> usr/sbin
├── snap
├── srv
├── sys
├── tmp
├── usr
└── var

25 carpetas

Esta lista no es exhaustiva y distintas distribuciones y sistemas podrían ser configurados de forma distinta.

4.2. Navegando el sistema de archivos de Linux

Ruta absoluta vs ruta relativa

La ruta absoluta es la ruta completa de la carpeta raíz al archivo o a la carpeta. Siempre comienza con un /. Por ejemplo, /home/john/documents.

La ruta relativa, por otro lado, es la ruta desde la carpeta actual al archivo de destino o a la carpeta. No comienza con un /. Por ejemplo, documents/work/project.

Localizando tu carpeta actual usando el comando pwd

Es fácil perder tu camino en el sistema de archivos de Linux, especialmente si eres nuevo en la línea de comandos. Puedes localizar tu carpeta actual usando el comando pwd.

Aquí hay un ejemplo:

pwd
# output
/home/zaira/scripts/python/free-mem.py

Cambiando carpetas usando el comando cd

El comando para cambiar carpetas es cd y significa "cambiar carpeta - change directory en inglés". Puedes usar el comando cd para navegar hacia otra carpeta diferente.

Puedes usar una ruta relativa o una ruta absoluta.

Por ejemplo, si quieres navegar la estructura de archivos de abajo (siguiendo las líneas rojas):

y estás en "home", el comando sería así:

cd home/bob/documents/work/project

Otros atajos de cd usado comúnmente son:

4.3. Manejando archivos y carpetas

Cuando se trabaja con archivos y carpetas, podrías querer copiar, mover, quitar, y crear archivos y carpetas nuevas. Aquí hay algunos comandos que te pueden ayudar con eso.

💡Consejo: Puedes diferenciar entre un archivo y una carpeta mirando la primera letra en la salida de ls -l. Un '-' representa un archivo y un 'd' representa una carpeta.

Creando nuevas carpetas usando el comando mkdir

Puedes crear una carpeta vacía usando el comando mkdir.

# creates an empty directory named "foo" in the current folder
mkdir foo

También puedes crear carpetas recursivamente usando la opción -p.

mkdir -p tools/index/helper-scripts
# output of tree
.
└── tools
    └── index
        └── helper-scripts

3 directories, 0 files

Creando nuevos archivos usando el comando touch

El comando touch crea un archivo vacío. Puedes usarlo así:

# creates empty file "file.txt" in the current folder
touch file.txt

Los nombres del archivo pueden ser encadenados si quieres crear múltiples archivos en un solo comando.

# creates empty files "file1.txt", "file2.txt", and "file3.txt" in the current folder

touch file1.txt file2.txt file3.txt

Eliminando archivos y carpetas usando el comando rm y rmdir

Puedes usar el comando rm para eliminar ambos archivos y carpetas no vacías.

🛑 Fíjate que deberías usar el argumento -f con cuidado ya que no te preguntará antes de eliminar un archivo. También, ten cuidado cuando ejecutas comandos rm en la carpeta root ya que podría resultar en eliminar archivos importantes de sistema.

Copiando archivos usando el comando cp

Para copiar archivos en Linux, usa el comando cp.

• Sintaxis para copiar archivos:cp source_file destination_of_file

Este comando copia un archivo llamado file1.txt a una nueva ubicación del archivo /home/adam/logs.

cp file1.txt /home/adam/logs

El comando cp también crea una copia de un archivo con el nombre provisto.

Este comando copia un archivo llamado file1.txt a otro archivo llamado file2.txt en la misma carpeta.

cp file1.txt file2.txt

Moviendo y renombrando archivos y carpetas usando el comando mv

El comando mv se usa para mover archivos y carpetas de una carpeta a otra.

Sintaxis para mover archivos: mv source_file destination_directory

Ejemplo: Mover un archivo llamado file1.txt a una carpeta llamada backup:

mv file1.txt backup/

Para mover una carpeta y sus contenidos:

mv dir1/ backup/

Renombrando archivos y carpetas en Linux también se hace con el comando mv.

Sintaxis para renombrar archivos: mv old_name new_name

Ejemplo: Renombrar un archivo de file1.txt a file2.txt:

mv file1.txt file2.txt

Renombrar una carpeta de dir1 a dir2:

mv dir1 dir2

4.4. Localizando archivos y carpetas usando el comando find

El comando find te permite buscar eficientemente archivos, carpetas, y un caracter y dispositivos de bloque.

Abajo está la sintaxis del comando find:

find /path/ -type f -name file-to-search

Donde,

• /path es la ruta donde el archivo se espera ser encontrado. Este es el punto de comienzo para buscar archivos. La ruta también pueder ser / o . el cual representa la raíz y la carpeta actual, respectivamente.
• -type representa los descriptores del archivo. Pueden ser cualquiera de lo de abajo: f – Archivo regular tales como archivos de texto, imágenes, y archivos ocultos. d – Carpeta. Estosson las carpetas bajo consideración. l – Enlace Simbólico. Los enlaces simbólicos apunta a archivos y son similares a atajos. c – Dispositivos de Caracteres. Archivos que se usan para acceder a dispositivos de carecteres se llaman archivos de dispositivo de caracter. Los drivers se comunican con dispositivos de caracteres enviando y recibiendo caracteres individuales (bytes, octetoss). Ejemplos incluyen teclados, tarjetas de sonido, y el ratón. b – Dispositivos de Bloque. Archivos que se usan para acceder a dispositivos de bloque se llaman archivos de dipositivos de bloque. Los drivers se comunican con dispositivos de bloque enviando y recibiendo bloques enteros de datos. Ejemplos incluyen USB y CD-ROM.
• -name es el nombre del tipo de archivo que quieres buscar.

Cómo buscar archivos por nombre o extensión

Supón que necesitamos encontrar archivos que contienen "style" en sus nombres. Usaremos este comando

find . -type f -name "style*"
#output
./style.css
./styles.css

Ahora digamos que queremos encontrar archivos con una extensión particular como .html. Modificaremos el comando así:

find . -type f -name "*.html"
# output
./services.html
./blob.html
./index.html

Cómo buscar archivos ocultos

Un punto al comienzo del nombre de archivo representa archivos ocultos. Son ocultos normalmente pero pueden ser vistos con ls -a en la carpeta actual.

Podemos modificar el comando find como se muestra abajo para buscar archivos ocultos:

find . -type f -name ".*"

Listar y encontrar archivos ocultos

ls -la
# contenido de las carpetas
total 5
drwxrwxr-x  2 zaira zaira 4096 Mar 26 14:17 .
drwxr-x--- 61 zaira zaira 4096 Mar 26 14:12 ..
-rw-rw-r--  1 zaira zaira    0 Mar 26 14:17 .bash_history
-rw-rw-r--  1 zaira zaira    0 Mar 26 14:17 .bash_logout
-rw-rw-r--  1 zaira zaira    0 Mar 26 14:17 .bashrc

find . -type f -name ".*"
# salida de find
./.bash_logout
./.bashrc
./.bash_history

Arriba puedes ver una lista de archivos ocultos en mi carpeta home.

Cómo buscar archivos log y archivos de configuración

Los archivos logs usualmente tienen la extensión .log, y podemos encontrarlos así:

 find . -type f -name "*.log"

De forma similar, podemos buscar archivos de configuración de esta forma:

 find . -type f -name "*.conf"

Cómo buscar otros archivos por tipo

Podemos buscarpor archivos de bloque de caracteres proveyendo c a -type:

find / -type c

De forma similar, podemos encontrar archivos de bloque de dispositivos usando b:

find / -type b

Cómo buscar carpetas

En el ejemplo de abajo, encontramos las carpetas usando el argumento -type d.

ls -l
# lista el contenido de las carpetas
drwxrwxr-x 2 zaira zaira 4096 Mar 26 14:22 hosts
-rw-rw-r-- 1 zaira zaira    0 Mar 26 14:23 hosts.txt
drwxrwxr-x 2 zaira zaira 4096 Mar 26 14:22 images
drwxrwxr-x 2 zaira zaira 4096 Mar 26 14:23 style
drwxrwxr-x 2 zaira zaira 4096 Mar 26 14:22 webp 

find . -type d 
# salida de find mostrando carpetas
.
./webp
./images
./style
./hosts

Cómo buscar archivos por tamaño

Un uso increíblemente útil del comando find es listar archivos basados en un tamaño particular.

find / -size +250M

Aquí, estamos listando archivos cuyos tamaños exceden los 250MB.

Otras unidades incluyen:

• G: GigaBytes.
• M: MegaBytes.
• K: KiloBytes
• c : bytes.

Sólo reemplaza con la unidad relevante.

find <directory> -type f -size +N<Unit Type>

Cómo buscar archivos por tiempo de modificación

Usando el argumento -mtime, puedes filtrar archivos y carpetas basado en el tiempo de modificación.

find /path -name "*.txt" -mtime -10

Por ejemplo,

• -mtime +10 significa que estás buscando un archivo que se modificó hace 10 días.
• -mtime -10 significa menos de 10 días.
• -mtime 10 si te salteas + o – significa exactamente 10 días.

4.5. Comandos Básicos para ver archivos

Concatena y muestra archivos usando el comando cat

El comando cat en Linux se usa para mostrar los contenidos de un archivo. También puede ser usado para concatenar y crear nuevos archivos.

Aquí está la sintaxis básica del comando cat:

cat [opciones] [archivo]

La forma más simple de usar cat es sin ninguna opción o argumento. Esto mostrará los contenidos del archivo en la terminal.

Por ejemplo, si quieres mostrar los contenidos de un archivo llamado file.txt, puedes usar el siguiente comando:

cat file.txt

Esto mostrará todos los contenidos del archivo en la termina de una sola vez.

Ver archivos de texto de forma interactiva usando less y more

Mientras que cat muestra todo el archivo de una sola vez, less y more te permite ver los contenidos de un archivo de forma interactiva. Esto es útil cuando quieres desplazarte a través de un archivo grande o buscar por contenido específico.

La sintaxis del comando less es:

less [opciones] [archivo]

El comando more es similar a less pero tiene menos características. Se usa para mostrar los contenidos de un archivo en una pantalla a la vez.

La sintaxis del comando more es:

more [opciones] [archivo]

Para ambos comandos, puedes usar el la barra de espacio para desplazarte a una página abajo, la tecla Enter para desplazarte una línea abajo, y la tecla q para salir del visualizador.

Para moverte hacia atrás puedes usar la tecla b, y para moverte hacia adelante puedes usar la tecla f.

Mostrando la última parte de los archivos usando tail

A veces podrías necesitar ver solo las últimas líneas de un archivo en vez de todo el archivo. El comando tail en Linux se usa para mostrar la última parte de un archivo.

Por ejemplo, tail file.txt mostrará las últimas 10 líneas del archivo file.txt por defecto.

Si quieres mostrar un número distinto de líneas, puedes usar la opción -n seguido del número de líneas que quieres mostrar.

# Muestra las últimas 50 líneas del archivo file.txt
tail -n 50 file.txt

💡Consejo: Otro uso de tail es su opción inmediata (-f). Esta opción te permite ver los contenidos de un archivo a medida que están siendo escritos. Esto es una utilidad útil para ver y monitorear archivos log en tiempo real.

Mostrar el comienzo de los archivos usando head

Así como tail muestra la última parte de un archivo, puedes usar el comando head en Linux para mostrar el inicio de un archivo.

Por ejemplo, head file.txt mostrará las 10 primera líneas del archivo file.txt por defecto.

Para cambiar el número de líneas mostradas, puedes usar la opción -n seguido del número de líneas que quieres mostrar.

Contando palabras, líneas, y caracteres usando wc

Puedes contar palabras, líneas y caracteres en un archivo usando el comando wc.

Por ejemplo, ejecutando wc syslog.log me dio la siguiente salida:

1669 9623 64367 syslog.log

En la salida de arriba,

• 1669 representa el número de líneas en el archivo syslog.log.
• 9623 representa el número de palabras en el archivo syslog.log.
• 64367 representa el número de caracteres en el archivo syslog.log.

Así que, el comando wc syslog.log contó 1669 líneas 9623 palabras, y 64367 caracteres en el archivo syslog.log.

Comparando archivo línea por línea usando diff

Comparando y encontrando diferencias entre dos archivos es una tarea común en Linux. Puedes comparar dos archivos justo en la línea de comandos usando el comando diff.

La sintaxis básica del comando diff es:

diff [opciones] archivo1 archivo2

Aquí hay dos archivos, hello.py y also-hello.py, que compararemos usando el comando diff:

# contenido de hello.py

def greet(name):
    return f"Hola, {name}!"

user = input("Ingresa tu nombre: ")
print(greet(user))
# contenido de also-hello.py

more also-hello.py
def greet(name):
    return fHola, {name}!

user = input(Ingresa tu nombre: )
print(greet(user))
print("¡Un placer en conocerte!")

1. Verifica si los archivos son similares o no.

diff -q hello.py also-hello.py
# Salida
Files hello.py and also-hello.py differ

2.   Ve cómo los archivos difieren. Para eso, puedes usar el argumento -u para ver una salida unificada:

diff -u hello.py also-hello.py
--- hello.py    2024-05-24 18:31:29.891690478 +0500
+++ also-hello.py    2024-05-24 18:32:17.207921795 +0500
@@ -3,4 +3,5 @@

 user = input(Ingresa tu nombre: )
 print(greet(user))
+print("Un placer en conocerte")

En la salida de arriba:

• --- hello.py 2024-05-24 18:31:29.891690478 +0500 indica el archivo siendo comparado y su marca de tiempo.
• +++ also-hello.py 2024-05-24 18:32:17.207921795 +0500 indica el otro archivo siendo comparado y su marca de tiempo.
• @@ -3,4 +3,5 @@ muestra los número de línea donde los cambios ocurren. En estecaos, indica que las líneas 3 a 4 en el archivo original ha cambiado a las líneas 3 a 5 en el archivo modificado.
• user = input(Ingresa tu nombre: ) es una línea del archivo original.
• print(greet(user)) es otra línea del archivo original.
• print("Un placer en conocerte") es la línea adicional en el archivo modificado.

3.   Para ver el diff en un formato lado a lado, puedes usar el argumento -y:

diff -y hello.py also-hello.py
# Salida
def greet(name):                        def greet(name):
    return fHola, {name}!                        return fHola, {name}!

user = input(Ingresa tu nombre: )                    user = input(Enter your name: )
print(greet(user))                        print(greet(user))
                                        >    print("Un placer en conocerte")

En la salida:

• Las líneas que están en ambos archivos se muestran lado a lado.
• Las líneas que son distintas se muestran con un símbolo > indicando que la línea está presente solamente en uno de los archivos.

Parte 5: Lo Esencial sobre Edición de Texto en Linux

Las habilidades de edición de texto usando la línea de comandos son una de las habilidades más cruciales en Linux. En esta sección, aprenderás cómo usar dos editores de textos populares en Linux: Vim y Nano.

Te sugiero que domines cualquier editor de texto de tu gusto y apegarte a él. Te ahorrará tiempo y te hará más productivo. Vim y nano son opciones seguras ya que están presentes en la mayoría de las distribuciones de Linux.

5.1. Dominando Vim: La Guía Completa

Introducción a Vim

Vim es una herramienta de edición de texto popular para la línea de comandos. Vim tiene sus ventajas: es poderoso, personalizable, y rápido. Aquí hay algunas razones de por qué deberías considerar aprender Vim:

• La mayoría de los servidores son accedidos a través de un CLI, así que en administración de sistemas, no es necesario que tengas los lujos de un GUI. Pero Vim te respalda – siempre estarás allí.
• Vim usa un enfoque centrado al teclado, ya que está diseñado para ser usado sin un ratón, lo cual puede acelerar significativamente las tareas de edición una vez que has aprendido los atajos de teclado. Esto también lo hace más rápido que las herramientas GUI.
• Algunas utilidades de Linux, por ejemplo edición de cron jobs, funcionan en el mismo formato de edición como Vim.
• Vim es apropiado para todos – usuarios principiantes y avanzados. Vim suporta búsquedas de cadena complejas, resaltación de búsquedas, y mucho más. A través de los plugins, Vim provee capacidades extendidas para los desarrolladores y administradores de sistema que incluyen completación de código, resaltación de sintaxis, gestión de archivos, control de versiones, y más.

Vim tiene dos variaciones: Vim (vim) y Vim pequeño (vi). Vim pequeño es una versión más pequeña de Vim que carece de algunas características de Vim.

Cómo comenzar usando vim

Comienza usando Vim con este comando:

vim your-file.txt

your-file.txt puede ser un nuevo archivo o un archivo existente que quieres editar.

Navegando con Vim: Dominando modos de movimiento y comando

A principios del CLI, los teclados no tenían teclas de flecha. Por lo tanto, la navegación se hacía usando el conjunto de teclas disponibles, hjkl siendo uno de ellos.

Siendo centrado al teclado, usando las teclas hjkl pueden acelerar inmensamente las tareas de edición de texto.

Nota: aunque las teclas de flecha funcionan bien totalmente, todavías puedes experimentar con las teclas hjkl para navegar. Algunas personas encuentran esta forma de navegar eficiente.

💡Consejo: Para recordar la secuencia de hjkl, usa esto: hang back, jump down, kick up, leap forward (quedarse atrás, saltar hacia abajo, patear, saltar hacia adelante).

Los tres modos de Vim

Necesitas conocer los 3 modos de operando de Vim y cómo cambiarlos. Las pulsaciones de teclas se comportan de forma distinta en cada modo de comando. Los tres modos son los siguientes:

1. Modo comando.
2. Modo edición.
3. Modo Visual.

Modo Comando. Cuando comienzas con Vim, llegas al modo comando por defecto. Este modo te permite acceder a otros módulos.

⚠ Para cambiar a otros modos, necesitas estar presente en el modo comando primero.

Modo edición

Este modo te permite hacer cambios al archivo. Para entrar el modo edición, presiona I mientras estás en modo comando. Fíjate el conmutador '-- INSERT' al final de la pantalla.

Modo visual

Este modo te permite trabajar en un solo caracter, un bloque de texto, o líneas de texto. Vamos a descomponerlo en pasos sencillos. Recuerda, usa las combinaciones de abajo cuando estés en modo comando.

• Shift + V → Selecciona múltiples líneas.
• Ctrl + V → Modo bloque.
• V → Mode caracter.

El modo visual viene bien cuando necesitas copiar y pegar o editar líneas en masa.

Modo comando extendido.

El modo comando extendido te permite realizar operaciones avanzadas como buscar, establecer números de líneas, y resaltar texto. Cubriremos el modo extendido en la próxima sección.

¿Cómo mantener el rumbo? Si te olvidas de tu modo actual, solo presiona ESC dos veces y estarás de vuelta en Modo Comando.

Editando eficientemente en Vim: Copiar/pegar y buscar

1. Cómo copiar y pegar en Vim

Copiar-pegar es conocido como 'yank' y 'put' en términos de Linux. Para copiar-pegar, sigue estos pasos:

• Selecciona texto en modo visual.
• Presiona 'y' para copiar/ yank.
• Mueve tu cursor a la posición requerida y presiona 'p'.

2. Cómo buscar texto en Vim

Cualquier serie de cadenas puede ser buscado con Vim usando el / en modo comando. Para buscar, usa /string-to-match.

En el modo comando, escribe :set hls y presiona enter. Busca usando /string-to-match. Esto resaltará las búsquedas.

Busqueamos unas pocas cadenas:

3. Cómo salir de Vim

Primero, pásate a modo comando (presionando escape dos veces) y luego usa estos argumentos:

• Salir sin guardar → :q!
• Salir y guardar → :wq!

Atajos en Vim: Haciendo la edición más rápido

Nota: todos estos atajos funcionan solamente en el modo comando.

• Navegación básica
• h: Mover a la izquierda
• j: Mover hacia abajo
• k: Mover hacia arriba
• l: Mover a la derecha
• 0: Mover al principio de la línea
• $: Mover al final de la línea
• gg: Mover al principio del archivo
• G: Mover al final del archivo
• Ctrl+d: Mover media página hacia abajo
• Ctrl+u: Mover media página hacia arriba
• Editando
• i: Ingresa modo insertar antes del cursor
• I: Ingresa el modo instertar al principio de la línea
• a: Ingresa el modo insertar después del cursor
• A: Ingresa el modo insertar al final de la línea
• o: Abre una nueva línea debajo de la línea actual e ingresa el modo insertar
• O: Abre una nueva línea arriba de la línea actual e ingresa el modo insertar
• x: Elimina el caracter debajo del cursor
• dd: Elimina la línea actual
• yy: Yank (copia) la línea actual (usa esto en modo visual)
• p: Pegar debajo del cursor
• P: Pegar arriba del cursor
• Buscando y Reemplazando
• /: Buscar un patrón el cual te llevará a la próxima ocurriencia
• ?: Buscar un patrón que te llevará a la ocurrencia previa
• n: Repite la última búsqueda en la misma dirección
• N: Repite la última búsqueda en la dirección opuesta
• :%s/old/new/g: Reemplaza todas las ocurrencias de old con new en el archivo
• Saliendo
• :w: Guarda el archivo pero no sale
• :q: Sale de Vim (falla si hay cambios no guardados)
• :wq or :x: Guardar y sale
• :q!: Sale sin guardar
• Múltiples Ventanas
• :split or :sp: Divide la ventana horizontalmente
• :vsplit or :vsp: Divide la ventana verticalmente
• Ctrl+w followed by h/j/k/l: Navega entre ventanas divididas

5.2. Dominando Nano

Comenzando con Nano: El editor de texto amigable

Nano es un editor de texto amigable que es fácil de usar y es perfecto para los principiantes. Está pre-instalado en la mayoría de las distribuciones de Linux.

Para crear un nuevo archivo usando Nano, usa el siguiente comando:

nano

Para empezar a editar un archivo existente con Nano, usa el siguiente comando:

nano filename

Lista de combinaciones de tecla en Nano

Estudiemos las combinaciones de tecla más importantes en Nano. Usará las combinaciones de tecla para realizar varias operaciones como guardar, salir, copiar, pegar, y más.

Escribir a un archivo y guardar

Una vez que abres Nano usando el comando nano, puedes comenzar con escribir texto. Para guardar el archivo, presiona Ctrl+O. Te aparecerá una ventana para que ingreses el nombre del archivo. Presiona Enter para guardar el archivo.

Salir de nano

Puedes salir de Nano presionando Ctrl+X. Si tienes cambios no guardados, Nano te mostrará una ventana para guardar los cambios antes de salir.

Copiar y pegar

Para seleccionar una región, usa ALT+A. Un marcador aparecerá. Usa las flechas para seleccionar el texto. Una vez seleccionado, sale del marcador con ALT+^.

Para copiar el texto seleccionado, presiona Ctrl+K. Para guardar el texto copiado, presiona Ctrl+U.

Cortar y pegar

Selecciona la región con ALT+A. Una vez seleccionado, corta el texto con Ctrl+K. Para pegar el texto cortado, presiona Ctrl+U.

Navegación

Usa Alt \ para moverte al principio del archivo.

Usa Alt / para moverte al final del archivo.

Viendo números de línea

Cuando abres un archivo con nano -l filename, puedes ver los números de línea en el lado izquierdo del archivo.

Buscando

Puedes buscar un número de línea específico con ALt + G. Ingresa el número de línea al prompt y presiona Enter.

También puedes iniciar una búsqueda de una cadena con CTRL + W y presiona Enter. Si quieres buscar hacia atrás, puedes presionar Alt + W después de iniciar la búsqueda con Ctrl + W.

Resumen de combinaciones de tecla en Nano

• General
• Ctrl+X: Sale de Nano (sale una ventana para guarda si se hacen cambios)
• Ctrl+O: Guarda el archivo
• Ctrl+R: Lee un archivo en un archivo actual
• Ctrl+G: Muestra el texto de ayuda
• Editando
• Ctrl+K: Corta la línea actual y lo almacena en el cutbuffer
• Ctrl+U: Guarda los contenidos del cutbuffer en la línea actual
• Alt+6: Copia la línea actual y lo almacena en el cutbuffer
• Ctrl+J: Justifica el párrafo actual
• Navigación
• Ctrl+A: Se mueve al principio de la línea
• Ctrl+E: Se mueve al final de la línea
• Ctrl+C: Muestra el número de línea actual e información del archivo
• Ctrl+_ (Ctrl+Shift+-): Va a un número de línea específica (y opcionalmente, una columna)
• Ctrl+Y: Se desplaza una página arriba
• Ctrl+V: Se desplaza una página abajo
• Buscar y Reemplazar
• Ctrl+W: Buscar una cadena (luego Enter para búscar nuevamente)
• Alt+W: Repite la última búsqueda pero en la dirección opuesta
• Ctrl+\: Busca y reemplaza
• Misceláneos
• Ctrl+T: Invoca el corrector ortográfico, si está disponible
• Ctrl+D: Elimina el caracter debajo del cursor (no lo corta)
• Ctrl+L: Refresca (redibuja) la ventana actual
• Alt+U: Deshace la última operación
• Alt+E: Rehace la última operación sin terminar

Parte 6: La Programación en Bash

6.1. Definición de los scripts de Bash

Un script de Bash es un archivo que contiene una secuencia de comandos que son ejecutados por el programa de bash línea por línea. Ter permite realizar una serie de acciones, tales como navegar a una carpeta específica, crear una carpeta, y lanzar un proceso usando la línea de comandos.

Al guardar comandos en un script, puedes repetir la misma secuencia de pasos múltiples veces y ejecutarlos al correr el script.

6.2. Ventajas de los scripts de Bash

La programación en Bash es una herramienta poderosa y versátil para las tareas de administración de sistemas, gestionar los recursos del sistema, y realizar otras tareas de rutinas en sistemas Unix/Linux.

Algunas ventajas de la programación de scripts son:

• Automatización: Los scripts de Shell te permiten automatizar tareas y procesos repetitivos, ahorrando tiempo y reducir el riesgo de errores que pueden ocurrir con la ejecución manual.
• Portabilidad: Los scripts de Shell pueden ser ejecutados en varias plataformas y sistemas operativos, incluyendo Unix, Linux, macOS, e inclusive Windows a través del uso de emuladores o máquinas virtuales.
• Flexibilidad: Los scripts de Shell son bastantes personalizables y pueden ser fácilmente modificados para adaptarse a requerimientos específicos. También pueden ser combinados con otros lenguajes de programación o utilidades para crear scripts más poderosos.
• Accesibilidad: Los scripts de Shell son fáciles de escribir y no requieren ninguna herramienta o software especial. Pueden ser editados usando cualquier editor de texto, y la mayoría de sistemas operativos tienen un intérprete de shell incorporado.
• Integración: Los scripts de Shell pueden ser integrados con otras herramientas y aplicaciones, tales como bases de datos, servidores web, y servicios de la nube, permitiendo automatización más complejo y tareas de gestión de sistema.
• Depuración: Los scripts de Shell son fáciles de depurar, y la mayoría de los shells tienen herramientas de depuración y reporte de errores incorporados que pueden ayudar a identificar y arreglar problemas rápidamente.

6.3. Vista general del Shell de Bash y la Interfaz de Línea de Comandos

Los términos "shell" y "bash" son frecuentemente usados de forma intercambiable. Pero hay una diferencia sutil entre los dos.

El término "shell" se refiere a un programa que provee una interfaz de línea de comandos para interactuar con un sistema operativo. Bash (Bourne-Again SHell) es uno de los shell de Unix/Linux más usado comúnmente y es la shell predeterminada en muchas distribuciones de Linux.

Hasta ahora, los comandos que has estado haciendo eran básicamente ingresados en un "shell".

Aunque Bash es un tipo de shell, hay otras shells disponibles también, tales como Korn shell (ksh), C shell (csh), y Z shell (zsh). Cada shell tiene su propia sintaxis y conjunto de características, pero todos comparten el mismo propósito común de proveer una interfaz de línea de comandos para interactuar con el sistema operativo.

Puedes determinar tu tipo de shell usando el comando ps:

ps
# output:

    PID TTY          TIME CMD
  20506 pts/0    00:00:00 bash <--- the shell type
  20931 pts/0    00:00:00 ps

En resumen, mientras que "shell" es un término amplio que se refiere a cualquier programa que provee una interfaz de línea de comandos, "Bash" es un tipo específico de shell que es ampliamente usado en sistemas de Unix/Linux.

Nota: En esta sección, estaremos usando el shell "bash".

6.4. Cómo crear y ejecutar scripts de Bash

Convenciones de nombramiento de Script

Por convención de nombramiento, los scripts de Bash terminan con .sh. Sin embargo, los scripts de bash se pueden ejecutar perfectamente sin la extensión sh.

Agregando el Shebang

Los scripts de Bash comienzan con un shebang. El shebang es una combinación de bash # y bang ! seguido de la ruta del shell bash. Esta es la primer línea del script. El shebang le dice al shell para ejecutarlo a través del shell bash. Shebang es simplemente una ruta absoluta al intérprete del bash.

Abajo hay un ejemplo de la declaración del shebang.

#!/bin/bash

Puedes encontrar tu ruta del shell bash (lo cual puede variar de lo de arriba) usando el comando:

which bash

Creando tu primer script de bash

Nuestro primer script muesta un mensaje al usuario que ingrese una ruta. En retorno, sus contenidos serán listados.

Crea un archivo llamado run_all.sh usando cualquier editor de tu preferencia.

vim run_all.sh

Agrega los siguientes comandos en tu archivo y guárdalo:

#!/bin/bash
echo "Hoy es " `date`

echo -e "\ningresa la ruta a la carpeta"
read the_path

echo -e "\n tu ruta tiene los siguientes archivos y carpetas: "
ls $the_path

Echemos un vistazo más profundamente al script línea por línea. Estoy mostrando el mismo script nuevamente, pero esta vez con números de líneas.

  1 #!/bin/bash
  2 echo "Hoy es " `date`
  3
  4 echo -e "\ningresa la ruta a la carpeta"
  5 read the_path
  6
  7 echo -e "\n tu ruta tiene los siguientes archivos y carpetas: "
  8 ls $the_path

• Línea #1: El shebang (#!/bin/bash) apunta a la ruta del shell bash.
• Línea #2: El comando echo muestra la fecha y el tiempo actual en la terminal. Fíjate que el date está en comillas invertidas.
• Línea #4: Queremos que el usuario ingrese una ruta válida.
• Línea #5: El comando read lee la entrada y lo almacena en la variable the_path.
• Línea #8: El comando ls toma la variable con la ruta almacenada y muestra los archivos y las carpetas actuales.

Ejecutando el script de bash

Para hacer que el script sea ejecutable, asigna permisos de ejecución a tu usuario usando este comando:

chmod u+x run_all.sh

Aquí,

• chmod modifica la propiedad de un archivo para el usuario actual :u.
• +x agrega los derechos de ejecución al usuario actual. Esto significa que el usuario quien es el propietario ahora puede ejecutar el script.
• run_all.sh es el archivo que deseamos ejecutar.

Puedes ejecutar el script usando cualquier de los métodos mencionados:

• sh run_all.sh
• bash run_all.sh
• ./run_all.sh

Veámoslo la ejecución en acción 🚀

6.5. Lo básico de la Programación en Bash

Comentarios en la programación de bash

Los comentarios comienzan con un # en la programación de bash. Esto significa que cualquier línea que comience con un # es un comentario y será ignorado por el intérprete.

Los comentarios son muy útiles en la documentación del código, y es una buena práctica agregarlos para ayudar a otros que entiendan el código.

Estos son ejemplos de comentarios:

# Este es un comentario de ejemplo
# Estas dos líneas serán ignorados por el intérprete

Variables y tipos de datos en Bash

Las variables te permiten almacenar datos. Puedes usar variables para leer, acceder, y manipular datos en tu script.

No hay tipos de datos en Bash. En Bash, una variable es capaz de almacenar valores numéricos, caracteres individuales, o cadenas de caracteres.

En Bash, puedes usar y establecer los valores de variable en las siguientes formas:

1. Asignar el valor directamente:

country=Netherlands

2.  Asignar el valor basado en la salida obtenido de un programa o comando, usando substitución de comando. Fíjate que $ es requerido para acceder al valor de una variable existente.

same_country=$country

Esto asigna el valor de country a la nueva variable same_country.

Para acceder el valor de la variable, adjunta $ al nombre de la variable.

country=Netherlands
echo $country
# salida
Netherlands
new_country=$country
echo $new_country
# salida
Netherlands

Arriba, puedes ver un ejemplo de asignamiento e impresión de valores de variable.

Convenciones de nombramiento de Variable

En la programación de Bash, lo siguiente son convenciones de nombramiento de variable:

1. Los nombres de variables deberían comenzar con una letra o un guión bajo (_).
2. Los nombres de variables pueden contener letras, números, y guiones bajos (_).
3. Los nombres de variables son distinguen mayúsculas y minúsculas.
4. Los nombres de variables no deberían contener espacios o caracteres especiales.
5. Una nombres descriptivos que reflejan el propósito de la variable.
6. Evita usar palabras claves reservadas, tales como if, then, else, fi, y así sucesivamente como nombres de variables.

Aquí hay algunos ejemplos de nombres de variables válidos en Bash:

name
count
_var
myVar
MY_VAR

Y aquí hay algunos ejemplos de nombres de variables inválidos:

# Nombres de variables inválidos

2ndvar (nombre de variable comienza con un número)
my var (nombre de variable contiene un espacio)
my-var (nombre de variable contains un guión)

Siguiendo estas convenciones de nombramiento ayudan en hacer que los scripts de Bash sean más legibles y más fáciles de mantener.

Entradas y salidas en scripts de Bash

Recopilación de entradas

En esta sección, discutiremos algunos métodos para proveer entradas a nuestros scripts.

1. Leer las entradas de usuario y almacenarlos en una variable

Podemos leer la entrada de usuario usando el comando read.

#!/bin/bash
echo "What's your name?"
read entered_name
echo -e "\nWelcome to bash tutorial" $entered_name

2.   Leer de un archivo

Este código lee cada línea de un archivo llamado input.txt y lo imprime a la terminal. Estudiaremos los bucles while más tarde en esta sección.

while read line
do
  echo $line
done < input.txt

3.   Argumentos de línea de comandos

En un script de bash o función, $1 denota el argumento inicial pasado, $2 denota el segundo argumento pasado, y así sucesivamente.

Este script toma un nombre como argumento de línea de comandos e imprime un saludo personalizado.

#!/bin/bash
echo "Hello, $1!"

Hemos suplido Zaira como nuestro argumento al script.

Salida:

Mostrando la salida:

Aquí discutiremos algunos métodos para recibir salidas de los scripts.

1. Imprimiendo a la terminal:

echo "Hello, World!"

Esto imprime el texto "Hello, World!" a la terminal.

2.   Escribiendo a un archivo:

echo "This is some text." > output.txt

Esto escribe el teto "This is some text." a un archivo llamado output.txt. Fíjate que el operador > sobreescribe un archivo si éste ya tenía algo de contenido.

3.   Adjuntando a un file:

echo "More text." >> output.txt

Esto adjunta el texto "More text." al final del archivo output.txt.

4.   Redireccionando la salida:

ls > files.txt

Esto lista los archivos en la carpeta actual y escribela salida a un archivo llamado files.txt. Puede redireccionar la salida de cualquier comando a un archivo de esta forma.

Aprenderás sobre redirección de salida en detalle en la sección 8.5.

Declaraciones condicionales (if/else)

Las expresiones que producen un resultado booleano, sea verdadero o falso, son llamados condiciones. Hay varias formas de evaluar condiciones, incluyendo if, if-else, if-elif-else, y condicionales anidadas.

Sintaxis:

if [[ condition ]];
then
    statement
elif [[ condition ]]; then
    statement 
else
    do this by default
fi

Sintaxis de las declaraciones condicionales de bash

Podemos usar operadores lógicos tales como AND -a y OR -o para hacer comparaciones que tienen más significado.

if [ $a -gt 60 -a $b -lt 100 ]

Esta declaración verifica si ambas condiciones son true: a es más grande que 60 Y b es menor que 100.

Veamos un ejemplo de un script de Bash que usa declaraciones if, if-else, y if-elif-else para determinar si un número ingresado por el usuario es positivo, negativo, o cero:

#!/bin/bash

# Script to determine if a number is positive, negative, or zero

echo "Please enter a number: "
read num

if [ $num -gt 0 ]; then
  echo "$num is positive"
elif [ $num -lt 0 ]; then
  echo "$num is negative"
else
  echo "$num is zero"
fi

El script primero muestra un mensaje al usuario para que ingrese un número. Luego, usa una declaración if para verificar si el número es más grande que 0. Si lo es, el script muestra que el número es positivo. Si el número no es más grande que 0, el script se mueve a la siguiente declaración, el cual es una declaración if-elif.

Aquí, el script verifica si el número es menor que 0. Si lo es, el script muestra que el número es negativo.

Finalmente, si el número no es más grande que 0 ni menor que 0, el script usa una declaración else para mostrar que el número es cero.

Viéndolo en acción 🚀

Bucles y ramificación en Bash

Bucle while

Los bucles while verifica una condición y un bucle hasta que la condición permanece true. Necesitamos proveer una declaración counter que incrementa el contador para controlar la ejecución del bucle.

En el ejemplo abajo, (( i += 1 )) es la declaración del counter que incrementa el valor de i. El bucle ejecutará exactamente 10 veces.

#!/bin/bash
i=1
while [[ $i -le 10 ]] ; do
   echo "$i"
  (( i += 1 ))
done

Bucle For

El bucle for, así como el bucle while, te permite ejecutar declaraciones en un número específico de veces. Cada bucle difiere en su sintaxis y uso.

En el ejemplo de abajo, el bucle iterará 5 veces.

#!/bin/bash

for i in {1..5}
do
    echo $i
done

Declaraciones Case

En Bash, las declaraciones case son usados para comparar un número dado contra una lista de patrones y ejecutar un bloque de código basado en el primer patrón que coincida. La sintaxis para una declaración case en Bash es como sigue:

case expression in
    pattern1)
        # código para ejecutar si la expresión coincide con el patrón1
        ;;
    pattern2)
        # código para ejecutar si la expresión coincide con el patrón2
        ;;
    pattern3)
        # código para ejecutar si la expresión coincide con el patrón3
        ;;
    *)
        # código para ejecutar si ninguno de los patrones de arriba coinciden con la expresión
        ;;
esac

Aquí, "expression" es el valor que queremos comparar, y "pattern1", "pattern2", "pattern3", y así sucesivamente son los patrones con las que queremos comparar.

El doble punto y coma ";;" separa cada bloque de código para ejecutar cada patrón. El asterisco "*" representa el case por defecto, el cual se ejecuta si ninguno de los patrones especificados coinciden con la expresión.

Veamos un ejemplo:

fruit="apple"

case $fruit in
    "apple")
        echo "This is a red fruit."
        ;;
    "banana")
        echo "This is a yellow fruit."
        ;;
    "orange")
        echo "This is an orange fruit."
        ;;
    *)
        echo "Unknown fruit."
        ;;
esac

En este ejemplo, ya que el valor de fruit es apple, el primer patrón ocincide, y el bloque de código que imprime This is a red fruit. se ejecuta. Si el valor de fruit era banana, el segundo patrón coincidiría y el bloque de código que imprime This is a yellow fruit. se ejecutaría, etcétera.

Si el valor de fruit no coincide con ninguno de los patrones especificados, el caso predeterminado se ejecuta, el cual imprime Unknown fruit..

Parte 7: Manejo de Paquetes de Software en Linux

Linux viene con varios programas incorporados. Pero podrías necesitar instalar nuevos programas basado en tus necesidades. También podrías necesitar actualizar las aplicaciones existentes.

7.1. Paquetes y Gestión de Paquetes

¿Qué es un paquete?

Un paquete es una colección de archivos que se empaquetan juntos. Estos archivos son esenciales para que un programa en particular se ejecute. Estos archivos contienen los archivos ejecutables del programa, librerías, y otros recursos.

Además de estos archivos requeridos para el programa para que se ejecute, los paquetes también contienen scripts de instalación, los cuales copian los archivo a donde se les necesita. Un programa podría contener muchos archivos y dependencias. Con los paquetes, es más fácil de manejar todos los archivos y dependencias de una sola vez.

¿Cuál es la diferencia entre fuente y binario?

Los programadores escriben código fuente en un lenguaje de programación. Este código fuente luego se compila en código máquina el cual la computadora puede entender. El código compilado se llama código binario.

Cuando descargas un paquete, puedes obtener el código fuente o el código binario. El código fuente es el código legible para los humanos que puede ser compilado en código binario. El código binario es el código compilado que la computadora puede entender.

Los paquetes fuentes pueden ser usados con cualquier tipo de máquina si el código fuente se compila apropiadamente. El binario, por otro lado, es código compilado que es específico a un tipo particular de máquina o arquitectura.

Puedes encontrar la arquitectura de tu máquina usando el comando uname -m.

uname -m
# output
x86_64

Dependencias de un paquete

Los programas frecuentemente comparten archivos. En vez de incluir estos archivos en cada paquete, un paquete separado puede proveerlos para todos los programas.

Para instalar un programa que necesita estos archivo, también debes instalar el paquete que los contiene. Esto se llama una dependencia de paquete. Especificando las dependencias hacen a los paquetes más pequeños y más sencillo al reducir los duplicados.

Cuando instalas un programa, sus dependencias también deben ser instalados. Las dependencias más requeridas usualmente ya están instaladas, pero unos pares extas podrían ser necesarios. Así que, no te sorprendas si varios paquetes son instalados juntamente con tu paquete deseado. Estos son dependencias necesarias.

Gestores de Paquetes

Linux ofrece un sistema comprensivo de gestión de paquetes para instalar, actualizar, configurar, y quitar software.

Con un gestor de paquetes, puedes obtener acceso a una base organizada de miles de paquetes de software juntamente teniendo la habilidad de resolver dependencias y verificar actualizaciones de software.

Los paquetes pueden ser manejados usando utilidades de línea de comando que pueden ser fácilmente automatizados por los administradores de sistema, o a través de una interfaz gráfica.

Canales/Repositorios de Software

⚠️ La gestión de paquetes es distinto para diferentes distros. Aquí, estamos usando Ubuntu.

Instalando software es un poco distinto en Linux comparado a Windows y Mac.

Linux usa repositorios para almacenar paquetes de software. Un repositorio es una colección de paquetes de software que están disponibles para instalación a través de un gestor de paquetes.

Un gestor de paquetes también almacena un índice de todos los paquetes disponibles de un repo. A veces el índice se reconstruye para asegurarse que está al día y para saber qué paquetes han sido actualizados o agregados al canal desde la última vez que fue verificado.

El proceso genérico de descargar software de un repo se parece algo así:

Si hablamos específicamente sobre Ubuntu,

1. El índice se busca usando apt update. (apt se explica en la próxima sección).
2. Los archivos/dependencias requeridas se solicitan según el índice usando apt install
3. Los paquetes y las dependencias se instalan de manera local.
4. Actualiza las dependencias y los paquetes cuando se requiere usando apt update y apt upgrade

En distros basados en Debian, puedes encontrar la lista de repos (repositorios) en  /etc/apt/sources.list.

7.2. Instalando un paquete a través de la Línea de Comandos

El comando apt es una herramienta de línea de comando poderosa, la cual es parte de Ubuntu y significa "Herramienta de Empaquetamiento Avanzado" ("Advanced Packaging Toll - APT").

apt, junto con los comandos que se empaquetan, provee los medios para instalar nuevos paquetes de software, actualizar paquetes de software existentes, actualizar el índice de lista de paquetes, e inclusive actualizar el sistema de Ubuntu completo.

Para ver los archivos log de la instalación usando apt, puedes ver el archivo /var/log/dpkg.log.

Lo siguiente son los usos del comando apt:

Instalando paquetes

Por ejemplo, para instalar el paquete htop, puedes usar el siguiente comando:

sudo apt install htop

Actualizando el índice de la lista de paquetes

El índice de lista de paquetes es una lista de todos los paquetes disponibles en los repositorios. Para actualizar el índice de la lista de paquetes local, puedes usar el siguiente comando:

sudo apt update

Actualizando los paquetes

Los paquetes instalados en tu sistema puede obtener actualizaciones que contienen correcciones de errores, parches de seguridad, y nuevas características.

Para actualizar los paquetes, puedes usar el siguiente comando:

sudo apt upgrade

Quitando los paquetes

Para quitar un paquete, como htop, puedes usar el siguiente comando:

sudo apt remove htop

7.3. Instalando un paquete a través de un Método Gráfico Avanzado – Synaptic

Si no estás cómodo con la línea de comando, puedes usar una aplicación GUI para instalar paquetes. Puedes alcanzar los mismos resultado como con la línea de comandos, pero con una interfaz gráfica.

Synaptic es una aplicación GUI de gestión de paquetes que ayuda en lista los paquetes instalados, su estado, actualizaciones pendientes, y así sucesivamente. Ofrece filtros personalizables para ayudarte en reducir los resultados de búsqueda.

También puedes hacer clic derecho en un paquete y ver más detalles como las dependencias, el mantenedor, y los archivos instalados.

7.4. Instalando paquetes descargados de un sitio web

Podrías querer instalar un paquete que has descargado de un sitio web, en vez de un repositorio de software. Estos paquetes se llaman archivos .deb.

Usando dpkg para instalar paquetes:  dpkg es una herramienta de línea de comando que se usa para instalar paquetes. Para instalar un paquete con dpkg, abre la Terminal y escribe lo siguiente:

cd directory
sudo dpkg -i package_name.deb

Nota: Reemplazar "directory" con la carptea donde el paquete se almacena y "package_name" con el nombre del archivo del paquete.

De forma alternativa, puedes hacer clic derecho, selecciona "Open With Other Application", y elige una app GUI de tu gusto.

💡 Consejo: En Ubuntu, puedes ver una lista de paquetes instalados con dpkg --list.

Parte 8: Temas de Linux Avanzados

8.1. Gestión de Usuario

Pueden haber múltiples usuario con niveles variantes de acceso en un sistema. En Linux, el usuario root tiene el nivel más alto de acceso y puede realizar cualquier operación en el sistema. Los usuarios regulares tienen acceso limitado y solamente puede realizar operaciones de las que se les ha dado permiso para hacer.

¿Qué es un usuario?

Una cuenta de usuario provee separación entre distintas personas y programas que pueden ejecutar comandos.

Los humanos identifican a los usuarios por nombre, ya que los nombres son fáciles con los que trabajar. Pero el sistema identifica a los usuarios por un número único llamado el ID de usuario (UID).

Cuando los usuarios humano inician sesión usando el nombre de usuario provisto, tienen que usar una contraseña para autorizarse a ellos mismos.

Las cuentas de usuario forman los fundamentos de la seguridad del sistema. La propiedad de archivo también está asociado con las cuentas de usuario y refuerza el control de acceso a los archivos. Cada proceso tiene una cuenta de usuario asociado que provee una capa de control para los administradores.

Hay tres tipos principales de cuentas de usuario:

1. Superusuario: El superusuario tiene acceso completo al sistema. El nombre del superusuario es root. Tiene un UID de 0.
2. Usuario de sistema: El usuario de sistema tiene cuentas de usuario que se usan para ejecutar servicios de sistema. Estas cuentas se usan para ejecutar servicios de sistema y no están destinados para la interacción humana.
3. Usuario regular: Los usuarios regulares son usuarios humanos que tienen acceso al sistema.

El comando id muestra el ID de usuario y el ID de grupo del usuario actual.

id
uid=1000(john) gid=1000(john) groups=1000(john),4(adm),24(cdrom),27(sudo),30(dip)... output truncated

Para ver las información básica de otro usuario, pasa el nombre de usuario como argumento al comando id.

id username

Para ver la información relacionado al usuario para los procesos, usa el comando ps con el argumento -u.

ps -u
# Salida
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1  16968  3920 ?        Ss   18:45   0:00 /sbin/init splash
root         2  0.0  0.0      0     0 ?        S    18:45   0:00 [kthreadd]

Por defecto, los sistemas usan el archivo /etc/passwd para almacenar información de usuario.

Aquí hay una línea del archivo /etc/passwd:

root:x:0:0:root:/root:/bin/bash

El archivo /etc/passwd contiene la siguiente información sobre cada usuario:

1. Nombre de usuario: root – El nombre de usuario de la cuenta de usuario.
2. Contraseña: x – La contraseña en formato encriptado para la cuenta de usuario que se almacena en el archivo /etc/shadow por razones de seguridad.
3. ID de Usuario (UID): 0 – El identificador numérico único para la cuenta de usuario.
4. ID de Grupo (GID): 0 – El identificador del grupo primario para la cuenta de usuario.
5. Información de Usuario: root – El nombre real para la cuenta de usuario.
6. Carpeta Home: /root – The home directory for the user account.
7. Shell: /bin/bash – El shell predeterminado para la cuenta de usuario. Un usuario de sistema podría usar /sbin/nologin si los inicios de sesión interactivos no están permitidos para ese usuario.

¿Qué es un grupo?

Un grupo es una colección de cuentas de usuario que comparten acceso compartido y recursos. Los grupos tienen nombres de grupo para identificarlos. El sistema identifica a los grupos por un número único llamado el ID del Grupo (GID).

Por defecto, la información sobre los grupos se almacenan en el archivo /etc/group.

Aquí hay una entrada del archivo /etc/group:

adm:x:4:syslog,john

Aquí está el desglose de los campos en la entrada dada:

1. Nombre de Grupo: adm – El nombre del grupo.
2. Contraseña: x – La contraseña para el grupo se almacena en el archivo /etc/gshadow por razones de seguridad. La contraseña es opcional y aparece vacío si no se pone una.
3. ID del Grupo (GID): 4 – El identificador numérico único para el grupo.
4. Miembros del Grupo: syslog,john – La lista de nombres de usuario que son miembros del grupo. En este caso, el grupo adm tiene dos miembros: syslog y john.

En esta entrada específica, el nombre del grupo es adm, el ID del grupo es 4, y el grupo tiene dos miembros: syslog y john. El campo contraseña es normalmente puesto a x para indicar que la contraseña del grupo se almacena en el archivo /etc/gshadow.

Los grupos están divididos en grupos 'primario' y 'suplementario'.

• Grupo primario: Cada usuario es asignado un grupo primario por defecto. Este grupo usualmente tiene el mismo nombre como el usuario y se crea cuando la cuenta de usuario se crea. Los archivos y las carpetas creadas por el usuario son normalmente propiedad de este grupo primario.
• Grupos Suplementarios: Estos son grupos extras a los que un usuario puede pertenecer además de su grupo primario. Los usuarios pueden ser miembros de múltiples grupos suplementarios. Estos grupos permiten a usuario que tenga permisos para los recursos compartidos entre esos grupos. Ayudan a proveer acceso a recursos compartidos sin afectar los permisos del archivo de sistema y manteniendo la seguridad intacta. Mientras que usuario debe pertenecer a un grupo primario, pertenecer a grupos suplementarios is opcional.

Control de acceso: encontrar y entender permisos de archivo

La propiedad de archivo puede ser visto usando el comando ls -l. La primera columna en la salida del comando ls -l muestra los permisos del archivo. Otras columnas muestra al propietario del archivo y el grupo al que el archivo pertenece.

Echemos un vistazo más cercano en la columna mode:

Mode define dos cosas:

• Tipo de archivo: El tipo de archivo define el tipo de archivo. Para archivos regulares que contienen un dato simple está en blanco -. Para otros tipos de archivos especiales el símbolo es distinto. Para una carpeta el cual es un archivo especial, es d. Los archivos especiales son tratados de forma diferente por el SO.
• Clases de Permiso: El próximo conjunto de caracteres define los permisos para el usuario, el grupo y para otros respectivamente..– User: Este es el propietario de un archivo y el propietario del archivo pertenece a esta clase.– Group: Los miembros del grupo del archivo pertenecen a esta clase– Other: Cualquier usuario que no son parte de las clases del usuario o del grupo pertenecen a esta clase.

💡Consejo: La propiedad de la carpeta se puede ver usando el comando ls -ld.

Cómo leer permisos simbólicos o los permisos de rwx

La representación de rwx es conocido como la representación Simbólca de los permisos. En el conjunto de permisos,

• r significa read (leer). Se indica en el primer caracter de la tríada.
• w significa write (escribir). Se indica en el segundo caracter de la tríada.
• x significa execution (ejecución). Se indica en el tercer caracter de la tríada.

Leer:

Para archivos regulares, los permisos de lectura permiten al archivo que se abra y sea leído solamente. Los usuarios no pueden modificar el archivo.

De forma similar para las carpetas, los permisos de lectura permiten el listado del contenido de la carpeta sin ninguna modificación en la carpeta.

Escribir:

Cuando los archivos tienen permisos, el usuario puede modificar (editar, eliminar) el archivo y guardarlo.

Para las carpetas, los permisos de escritura permiten a un usuario a modificar su contenido (crear, eliminar, y renombrar los archivos que contiene), y modificar el contenido de los archivos de los que el usuario tiene permiso.

Ejemplos de permisos en Linux

Ahora que sabemos cómo leer permisos, veamos algunos ejemplos.

-rwx------: Un archivo que es accesible y ejecutable solamente por su propietario.

-rw-rw-r--: Un archivo que está abierto a modificaciones por su propietario y su grupo pero no por otros.

drwxrwx---: Una carpeta que puede ser modificado por su propietario y su grupo.

Ejecutar:

Para los archivos, los permisos de ejecución permiten al usuario ejecutar un script ejecutable. Para las carpetas, el usuario los puede acceder, y acceder a detalles sobre los archivos en la carpeta.

Cómo cambiar los permisos de archivo y propiedad en Linux usando chmod y chown

Ahora que sabemos las bases de propiedad y permisos, veamos cómo podemos modificar los permisos usando el comando chmod.

Sintaxis de chmod:

chmod permissions filename

Donde,

• permissions puede ser leído, escrito, ejecutado o una combinación de ellos.
• filename es el nombre del archivo para los cuales los permisos necesitan para cambiar. Este parámetro también puede ser una lista  de archivos para cambiar permisos en masa.

Podemos cambiar los permisos usando dos modos:

1. Modo simbólico: este método usa símbolos como u, g, o para representar a los usuarios, a los grupos, y a los otros. Los permisos son representados como r, w, x para lectura, escritura, y ejecución, respectivamente. Puedes modificar los permisos usando +, - y =.
2. Modo absoluto: este método representa los permisos como números octales de 3 dígitos que van desde 0-7.

Ahora, veámoslos en detalle.

Cómo cambiar los permisos usando el Modo Simbólico

La tabla de abajo resume la representación del usuario:

Podemos usar operadores matemáticos para agregar, quitar, y asignar permisos. La tabla de abajo muestra el resumen:

Ejemplo:

Supongamos que tengo un script y quiero hacerlo ejecutable para el propietario del archivo zaira.

Los permisos de archivos actuales son como sigue:

Dividamos los permisos así:

Para agregar los derechos de ejecución (x) al propietario (u) usando el modo simbólico, podemos usar el comando de abajo:

chmod u+x mymotd.sh

Salida:

Ahora, podemos ver que los permisos de ejecución han sido agregados al propietario zaira.

Ejemplos adicionales para cambiar los permisos a través del método simbólico:

• Quitar los permisos de read y write para group y others: chmod go-rw.
• Quitar los permisos de read para others: chmod o-r.
• Asignando los permisos de write a group y sobreescribir el permiso existente: chmod g=w.

Cómo cambiar los permisos usando el Modo Absoluto

El modo absoluto usa los números para representar los permisos y operadores matemáticos para modificarlos.

La tabla de abajo muestra cómo podemos asignar permisos relevantes:

Los permisos pueden ser revocados usando la resta. La tabla de abajo muestra cómo quitar los permisos relevantes.

Ejemplo:

• Poner read (agregar 4) para user, read (agregar 4) y execute (agregar 1) para el grupo, y solamente execute (agregar 1) para los demás.

chmod 451 file-name

Así es como ejecutamos el cálculo:

Fíjate que esto es lo mismo que r--r-x--x.

• Quitar derechos de execution desde other y group.

Para quitar la ejecución de other y group, resta 1 de la parte de ejecución de los 2 últimos octatos.

• Asigna read, write y execute a user, read y execute a group y solamente read a los demás.

Esto debería ser lo mismo que rwxr-xr--.

Cómo cambiar la Propiedad usando el comando chown

Luego, aprenderemos cómo cambiar la propiedad de un archivo. Puedes cambiar la propiedad de un archivo o carpeta usando el comando chown. En algunos casos, cambiar la propiedad requiere permisos sudo.

Sintaxis de chown:

chown user filename

Cómo cambiar la propiedad de usuario con chown

Vamos a transferir la propiedad del usuario zaira al usuario news.

chown news mymotd.sh

El comando para cambiar la propiedad: sudo chown news mymotd.sh.

Salida:

Cómo cambiar la propiedad del usuario y del grupo simultáneamente

También podemos usar chown para cambiar el usuario y el grupo simultáneamente.

chown user:group filename

Cómo cambiar la propiedad de carpeta

Puedes cambiar la propiedad recursivamente para los contenidos en una carpeta. El ejemplo de abajo cambia la propiedad de la carpeta /opt/script para permitir al usuario ser admin.

chown -R admin /opt/script

Cómo cambiar la propiedad de grupo

En caso que solo necesitemos cambiar el propietario del grupo, podemos usar chown al predecir el nombre de grupo con un dos puntos :.

chown :admins /opt/script

Cómo cambiar entre usuarios

Podemos cambiar entre usuarios usando el comando su.

[user01@host ~]$ su user02
Password:
[user02@host ~]$

Cómo ganar acceso de superusuario

El super usuario o el usuario root tiene el nivel de acceso másalto en un sistema Linux. El usuario root puede realizar cualquier operación en el sistema. El usuario root puede acceder a todos los archivos y carpetas, instalar y quitar software, y modificar o sobreescribir configuraciones de sistema.

Un gran poder conlleva una gran responsabilidad. Si el usuario root está comprometido, alguien puede ganar control completo sobre el sistema. Es aconsejable usar las cuentas de usuario root solamente cuando sea necesario.

Si omites el nombre de usuario, el comando su cambia a la cuenta de usuario root por defecto.

[user01@host ~]$ su
Password:
[root@host ~]#

Otra variante del comando su es su -. El comando su cambia a la cuenta de usuario root pero no cambia las variables de entorno. El comando su - cambia a la cuenta de usuario root y cambia las variables de entorno a los del usuario objetivo.

Ejecutar comandos con sudo

Para ejecutar comandos como el usuario root sin cambiar a la cuenta de usuario root, puedes usar el comando sudo. El comando sudo te permite ejecutar comandos con privilegios elevados.

Ejecutar comandos con sudo es una opción más segura que ejecutar los comandos como usuario root. Esto es porque, solamente un conjunto específico de usuarios se les da el permiso de ejecutar comandos con sudo. Esto se define en el archivo /etc/sudoers.

También, sudo muestra en un archivo log todos los comandos con los que ejecuto, proveyendo una pista de auditoría de quién ejecutó qué comando y cuándo.

En Ubuntu, puedes encontrar los archivos log de auditoría aquí:

cat /var/log/auth.log | grep sudo

Para un usuario que no tiene acceso a sudo, se marca en los registros y muestra un mensaje así:

user01 is not in the sudoers file.  This incident will be reported.

Manejar cuentas de usuario locales

Crear usuarios desde la línea de comandos

El comando usado para agregar un nuevo usuario es:

sudo useradd username

Este comando configura un directorio home del usuario y crea un grupo privado designado por el nombre de usuario del usuario. Actualmente, a la cuenta le falta una contraseña válida, previniendo al usuario de iniciar sesión hasta que una contraseña se cree.

Modificar los usuarios existentes

El comando usermod se usa para modificar usuarios existentes. Aquí hay algunas de las opciones comunes usados con el comando usermod:

Aquí algunos de los ejemplos del comando usermod en Linux:

Cambiar un nombre de inicio de sesión del usuario:

 sudo usermod -l newusername oldusername

Cambiar una carpeta de inicio del usuario:

 sudo usermod -d /new/home/directory -m username

Agregar un usuario a un grupo suplementario:

 sudo usermod -aG groupname username

Cambiar un shell del usuario:

 sudo usermod -s /bin/bash username

Bloquear una cuenta de usuario:

 sudo usermod -L username

Desbloquear una cuenta de usuario:

 sudo usermod -U username

Establecer una fecha de vencimiento para una cuenta de usuario:

 sudo usermod -e YYYY-MM-DD username

Cambiar el ID del usuario (UID):

 sudo usermod -u newUID username

Cambiar el grupo primario del usuario:

 sudo usermod -g newgroup username

Quitar un usuario de un grupo suplementario:

sudo gpasswd -d username groupname

Eliminar usuarios

El comando userdel se usa para eliminar una cuenta de usuario y archivos relacionados desde el sistema.

• sudo userdel username: quita los detalles del usuario desde /etc/passwd pero mantiene la carpeta de inicio del usuario.
• El comando sudo userdel -r username quita los detalles del usuario desde /etc/passwd y también elimina la carpeta de inicio del usuario.

Cambiar las contraseñas de usuario

El comando passwd se usa para cambiar la contraseña de usuario.

• sudo passwd username: pone la contraseña inicial o cambia la contraseña existente de nombre de usuario. También se usa para cambiar la contraseña del usuario actual que inició sesión.

8.2 Conectándose a Servidores Remotos a través de SSH

Accediendo a los servidores remotos es una de las tareas esenciales para administradores de sistema. Puedes conectarte a distintos servidores o acceder a bases de datos a través de tu máquina local y ejecutar comandos, todos usando SSH.

¿Qué es el protocol SSH?

SSH significa Shell Seguro (Secure Shell). Es un protocolo de red criptográfico que permite la comunicación segura entre dos sistemas.

El puerto predeterminado para SSH es 22.

Los dos participantes mientras se comunican a través de SSH son:

• El servidor: la máquina a la que quieres acceder.
• El cliente: El sistema desde el que estás accediendo al servidor.

La conexión a un servidor sigue estos pasos:

1. Iniciar una Conexión: El cliente envía una petición de conexión al servidor.
2. Intercambio de Claves: El servidor envía su clave pública al cliente. Ambos se ponen de acuerdo en el método de encripción a usar.
3. Generación de Clave de Sesión: El cliente y el servidor usan el intercambio de claves Diffie-Hellman para crear una clave de sesión compartida.
4. Autenticación de Cliente: El Cliente inicia sesión en el servidor usando una contraseña, clave privada, u otro método.
5. Comunicación Segura: Después de la autenticación, el cliente y el servidor se comunican de forma segura con encriptación.

¿Cómo conectarse a un servidor remoto usando SSH?

El comando ssh es una utilidad incorporada en Linux y también el predeterminado. Hace que el acceso a los servidores bastante fácil y seguro.

Aquí, estamos hablando sobre cómo el cliente haría una conexión al servidor.

Antes de conectarse a un servidor, necesitas tener la siguiente información:

• La dirección IP o el nombre de dominio del servidor.
• El nombre de usuario y contraseña del servidor.
• El número de puerto del que tienes acceso en el servidor.

La sintaxis básica del comando ssh es:

ssh username@server_ip

Por ejemplo, si tu nombre de usuario es john y la IP del servidor es 192.168.1.10, el comando sería:

ssh john@192.168.1.10

Después de eso, se te mostrará un mensaje para que ingreses la contraseña secreta. Tu pantalla se verá similar a esto:

john@192.168.1.10's password: 
Welcome to Ubuntu 20.04.2 LTS (GNU/Linux 5.4.0-70-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

  System information as of Fri Jun  5 10:17:32 UTC 2024

  System load:  0.08               Processes:           122
  Usage of /:   12.3% of 19.56GB   Users logged in:     1
  Memory usage: 53%                IP address for eth0: 192.168.1.10
  Swap usage:   0%

Last login: Fri Jun  5 09:34:56 2024 from 192.168.1.2
john@hostname:~$ # start entering commands

Ahora puedes ejecutar los comandos relevantes en el servidor 192.168.1.10.

⚠️ El puerto predeterminado para ssh es 22 pero también es vulnerable, ya que los hackers probablemente intentarán aquí primero. Tu servidor puede exponer otro puerto y compartir el acceso contigo. Para conectarse a un puerto distinto, usa el argumento -p.

ssh -p port_number username@server_ip

8.3. Análisis Sintáctico y Análisis de Archivos Log Avanzado

Los archivos log, cuando se configuren, son generados por tu sistema por una variedad de razones. Pueden ser usado para rastrear eventos de sistema, monitorear el rendimiento del sistema, y solventar problemas. Son útiles especialmente para los administradores de sistema cuando pueden rastrear errores de aplicación, eventos de red, y actividad de usuario.

Aquí hay un ejemplo de un archivo log:

# ejemplo de un archivo log
2024-04-25 09:00:00 INFO Startup: Application starting
2024-04-25 09:01:00 INFO Config: Configuration loaded successfully
2024-04-25 09:02:00 DEBUG Database: Database connection established
2024-04-25 09:03:00 INFO User: New user registered (UserID: 1001)
2024-04-25 09:04:00 WARN Security: Attempted login with incorrect credentials (UserID: 1001)
2024-04-25 09:05:00 ERROR Network: Network timeout on request (ReqID: 456)
2024-04-25 09:06:00 INFO Email: Notification email sent (UserID: 1001)
2024-04-25 09:07:00 DEBUG API: API call with response time over threshold (Duration: 350ms)
2024-04-25 09:08:00 INFO Session: User session ended (UserID: 1001)
2024-04-25 09:09:00 INFO Shutdown: Application shutdown initiated

Un archivo log usualmente contiene las siguientes columnas:

• Marca de tiempo: La fecha y el tiempo cuando el evento ocurrió.
• Nivel de Log: La severidad del evento (INFO, DEBUG, WARN, ERROR).
• Componente: El componente del sistema que generó el evento (Startup, Config, Database, User, Security, Network, Email, API, Session, Shutdown).
• Mensaje: Una descripción del evento que ocurrió.
• Información adicional: Información adicional relacionado al evento.

En sistemas de tiempo real, los archivos log tienden an ser miles de líneas de largo y son generados a cada segundo. Pueden ser verbosos dependiendo de la configuración. Cada columna en un archivo log es una pieza de información que puede ser usado para rastrear problemas. Esto hace que los archivos log sean difíciles de leer y de entender manualmente.

Aquí es donde viene el análisis de archivos log. El análisis estático de archivos log es el proceso de extraer información útil de los archivos log. Involucra descomponer los archivos log en piezas pequeñas más manejables, y extraer la información relevante.

La información filtrada también puede ser útil para crear alertas, reportes y paneles.

En esta sección, explorarás algunas de las técnicas para análisis de archivos log en Linux.

Extracción de texto usando grep

Grep es una utilidad incorporada de bash. Significa "Búsqueda global de expresiones regulares". Grep se usa para hacer coincidir cadenas en archivos.

Aquí hay algunos usos comunes de grep:

Buscar una cadena específica en un archivo:

 grep "search_string" filename

Este comando busca "search_string" en el archivo llamado filename.

Buscar de forma recursiva en las carpetas:

 grep -r "search_string" /path/to/directory

Este comando busca "search_string" en todos los archivos dentro de la carpeta especificada y sus sub-carpetas.

Ignorar mayúsculas y minúsculas mientras se busca:

 grep -i "search_string" filename

Este comando realiza una búsqueda sin importar mayúsculas o minúsculas de "search_string" en el archivo llamado filename.

Mostrar números de línea con líneas coincidentes:

 grep -n "search_string" filename

Este comando muestra los números de línea juntamente con las líneas coincidentes en el archivo llamado filename.

Cuenta el número de líneas coincidentes:

 grep -c "search_string" filename

Este comando cuenta el número de líneas que contiene "search_string" en el archivo llamado filename.

Invertir las coincidencias para mostrar líneas que no coinciden:

 grep -v "search_string" filename

Este comando muestra todas las líneas que no contienen "search_string" en el archivo llamado filename.

Busca una palabra entera:

 grep -w "word" filename

Este comando busca la palabra "word" entera en el archivo llamado filename.

Usar expresiones regulares extendidas:

 grep -E "pattern" filename

Este comando permite el uso de las expresiones regulares extendidas para una coincidencia de patrón más complejo en el archivo llamado filename.

💡 Consejo: Si hay múltiples archivos en una carpeta, puedes usar el comando de abajo para encontrar la lista de archivos que contienen las cadenas deseadas.

# encuentra la lista de archivos que contienen las cadenas deseadas
grep -l "String to Match" /path/to/directory

Extracción de texto usando sed

sed significa "editor de stream". Procesa flujo de datos, lo que significa que lee datos una línea a la vez. sed te permite buscar patrones y realizar acciones en las líneas que coinciden con esos patrones.

Sintaxis básica de sed:

La sintaxis básica de sed es como sigue:

sed [options] 'command' file_name

Aquí, command se usa para realizar operaciones como substitución, eliminación, inserción, y así sucesivamente, en los datos de texto. El nombre de archivo es el nombre del archivo que quieres procesar.

Uso de sed:

1. Substitución:

El argumento s se usa para reemplazar texto. El old-text se reemplaza con new-text:

sed 's/old-text/new-text/' filename

Por ejemplo, para cambiar todas las instancias de "error" a "warning" en el archivo log system.log:

sed 's/error/warning/' system.log

2. Imprimiendo líneas que contienen un patrón específico:

Usando sed para filtrar y mostrar las líneas que coinciden con un patrón específico:

sed -n '/pattern/p' filename

Por ejemplo, para encontrar todas las líneas que contienen "ERROR":

sed -n '/ERROR/p' system.log

3. Eliminar líneas que contienen un patrón específico:

Puedes eliminar líneas desde la salida que coinciden un patrón específico:

sed '/pattern/d' filename

Por ejemplo, para quitar todas las líneas que contienen "DEBUG":

sed '/DEBUG/d' system.log

4. Extrayendo campos específicos desde una línea log:

Puedes usar expresiones regulares para extraer partes de líneas. Supón que cada línea del archivo log comienza con una fecha en el formato "YYYY-MM-DD". Podrías extraer sólo la fecha de cada línea:

sed -n 's/^\([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\).*/\1/p' system.log

Análisis de Texto con awk

awk tiene la habilidad de separar cada línea fácilmente en los campos. Es adecuado para procesar texto estructurado como archivos log.

Sintaxis Básica de awk

La sintaxis básica de awk es:

awk 'pattern { action }' file_name

Aquí, pattern es una condición que se debe cumplir para que action se ejecute. Si el patrón se omite, la acción se ejecuta en cada línea.

En los próximos ejemplos, usarás este archivo de log como ejemplo:

2024-04-25 09:00:00 INFO Startup: Application starting
2024-04-25 09:01:00 INFO Config: Configuration loaded successfully
2024-04-25 09:02:00 INFO Database: Database connection established
2024-04-25 09:03:00 INFO User: New user registered (UserID: 1001)
2024-04-25 09:04:00 INFO Security: Attempted login with incorrect credentials (UserID: 1001)
2024-04-25 09:05:00 INFO Network: Network timeout on request (ReqID: 456)
2024-04-25 09:06:00 INFO Email: Notification email sent (UserID: 1001)
2024-04-25 09:07:00 INFO API: API call with response time over threshold (Duration: 350ms)
2024-04-25 09:08:00 INFO Session: User session ended (UserID: 1001)
2024-04-25 09:09:00 INFO Shutdown: Application shutdown initiated
  INFO

• Accediendo a columnas usando awk

Los campos en awk (separados por espacio de forma predeterminada) pueden ser accedidos usando $1, $2, $3, y así sucesivamente.

zaira@zaira-ThinkPad:~$ awk '{ print $1 }' sample.log
# salida
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25
2024-04-25

zaira@zaira-ThinkPad:~$ awk '{ print $2 }' sample.log
# salida
09:00:00
09:01:00
09:02:00
09:03:00
09:04:00
09:05:00
09:06:00
09:07:00
09:08:00
09:09:00

• Imprimir líneas que contienen un patrón específico (por ejemplo, ERROR)

awk '/ERROR/ { print $0 }' logfile.log

# salida
2024-04-25 09:05:00 ERROR Network: Network timeout on request (ReqID: 456)

Esto imprime todas las líneas que contienen "ERROR".

• Extraer el primer campo (Fecha y Hora)

awk '{ print $1, $2 }' logfile.log
# salida
2024-04-25 09:00:00
2024-04-25 09:01:00
2024-04-25 09:02:00
2024-04-25 09:03:00
2024-04-25 09:04:00
2024-04-25 09:05:00
2024-04-25 09:06:00
2024-04-25 09:07:00
2024-04-25 09:08:007
2024-04-25 09:09:00

Esto extraerá los dos primeros campos de cada línea, el cual en este caso sería la fecha y hora.

• Resumir las ocurrencias de cada nivel de log

awk '{ count[$3]++ } END { for (level in count) print level, count[level] }' logfile.log

# output
 1
WARN 1
ERROR 1
DEBUG 2
INFO 6

La salida será un resumen del número de ocurrencias de cada nivel de log.

• Filtra campos específicos (por ejemplo, donde el 3er campo es INFO)

awk '{ $3="INFO"; print }' sample.log

# salida
2024-04-25 09:00:00 INFO Startup: Application starting
2024-04-25 09:01:00 INFO Config: Configuration loaded successfully
2024-04-25 09:02:00 INFO Database: Database connection established
2024-04-25 09:03:00 INFO User: New user registered (UserID: 1001)
2024-04-25 09:04:00 INFO Security: Attempted login with incorrect credentials (UserID: 1001)
2024-04-25 09:05:00 INFO Network: Network timeout on request (ReqID: 456)
2024-04-25 09:06:00 INFO Email: Notification email sent (UserID: 1001)
2024-04-25 09:07:00 INFO API: API call with response time over threshold (Duration: 350ms)
2024-04-25 09:08:00 INFO Session: User session ended (UserID: 1001)
2024-04-25 09:09:00 INFO Shutdown: Application shutdown initiated
  INFO

Este comando extraerá todas las líneas donde el 3er campo es "INFO".

💡 Consejo: El separador predeterminado en awk es un espacio. Si tu archivo log usa un separador distinto, puedes especificarlo usando la opción -F. Por ejemplo, si tu archivo log usa un dos puntos como separador, puedes usar awk -F: '{ print $1 }' logfile.log para extraer el primer campo.

Análisis de archivos log con cut

El comando cut es una comando sencillo aunque potente usado para extraer secciones de texto de cada línea de la entrada. Siempre y cuando los archivos estén estructurados y cada campo esté delimitado por un caracter específico, tales como un espacio, tabulación, o un delimitador personalizado, cut hace un muy buen trabajo al extraer esos campos específicos.

La sintaxis básica del comando cut es:

cut [opciones] [archivo]

Algunas de las opciones usados comúnmente para el comando cut:

• -d : Especifica un delimitador usado como el separador de campo.
• -f : Selecciona los campos para que se muestren.
• -c : Especifica las posiciones de cada caracter.

Por ejemplo, el comando de abajo extraería el primer campo (separado por un espacio) de cada línea del archivo log:

cut -d ' ' -f 1 logfile.log

Ejemplos de uso de cut para análisis de archivos log

Digamos que tienes un archivo log estructurado como sigue, donde los campos están separados por espacio:

2024-04-25 08:23:01 INFO 192.168.1.10 User logged in successfully.
2024-04-25 08:24:15 WARNING 192.168.1.10 Disk usage exceeds 90%.
2024-04-25 08:25:02 ERROR 10.0.0.5 Connection timed out.
...

cut puede ser usado de las siguientes formas:

1. Extraer la hora de cada entrada del archivo log:

cut -d ' ' -f 2 system.log

# Output
08:23:01
08:24:15
08:25:02
...

Este comando usa un espacio como un delimitador y selecciona el segundo campo, el cual es el componente hora de cada entrada del archivo log.

2.  Extraer las direcciones IP de los archivos log:

cut -d ' ' -f 4 system.log

# Output
192.168.1.10
192.168.1.10
10.0.0.5

Este comando extraer el cuarto campo, el cual es la dirección IP de cada entrada del log.

3.  Extraer niveles de log (INFO, WARNING, ERROR):

cut -d ' ' -f 3 system.log

# Salida
INFO
WARNING
ERROR

Esto extrae el tercer campo el cual contiene el nivel log.

4.  Combinando cut con otros comandos:

La salida de otros comandos puede ser canalizado al comando cut. Digamos que quieres filtrar los logs antes de cortar. Puedes usar grep para extraer las líneas que contienen "ERROR" y luego usa cut para obtener información específica de esas líneas:

grep "ERROR" system.log | cut -d ' ' -f 1,2 

# Output
2024-04-25 08:25:02

Este comando primero filtra las líneas que incluyen "ERROR", luego extrae la fecha y hora de estas líneas.

5.  Extraer múltiples campos:

Es posible extraer múltiples campos a la vez al especificar un rango o una lista de campos separado por coma:

cut -d ' ' -f 1,2,3 system.log` 

# Salida
2024-04-25 08:23:01 INFO
2024-04-25 08:24:15 WARNING
2024-04-25 08:25:02 ERROR
...

El comando de arriba extrae los tres primeros campos de cada entrada log que son la fecha, hora, y nivel log.

Análisis sintáctico de archivos log con sort y uniq

Ordenar y quitar duplicados son operaciones comunes cuando se trabaja con archivos log. Los comandos sort y uniq son comandos poderosos usados para ordenar y quitar duplicados de las entradas, respectivamente.

Sintaxis básica de sort

El comando sort organiza las líneas de texto de forma alfabética o numérica.

sort [opciones] [archivo]

Algunas opciones claves para el comando sort:

• -n: Ordena el archivo asumiendo que los contenidos son numéricos.
• -r: Invierte el orden de sort.
• -k: Especifica una clave o número de columna con el cual ordena.
• -u: Ordena y quita líneas duplicadas.

El comando uniq se usa para filtrar o contar y reportar líneas repetidas en un archivo.

La sintaxis de uniq es:

uniq [opciones] [archivo_entrada] [archivo_salida]

Algunas opciones claves para el comando uniq son:

• -c: Prefija líneas por el número de ocurrencias.
• -d: Solamente imprime líneas duplicadas.
• -u: Solamente imprime líneas únicas.

Ejemplos de usar sort y uniq juntos para análisis de archivos log

Asumamos las siguientes de entradas de registro de ejemplo para estas demostraciones:

2024-04-25 INFO User logged in successfully.
2024-04-25 WARNING Disk usage exceeds 90%.
2024-04-26 ERROR Connection timed out.
2024-04-25 INFO User logged in successfully.
2024-04-26 INFO Scheduled maintenance.
2024-04-26 ERROR Connection timed out.

1. Ordenar entradas log por fecha:

sort system.log

# Salida
2024-04-25 INFO User logged in successfully.
2024-04-25 INFO User logged in successfully.
2024-04-25 WARNING Disk usage exceeds 90%.
2024-04-26 ERROR Connection timed out.
2024-04-26 ERROR Connection timed out.
2024-04-26 INFO Scheduled maintenance.

Esto ordena las entradas log de forma alfabética, el cual ordena efectivamente por fecha si la fecha es el primer campo.

2.  Ordenar y quitar duplicados:

sort system.log | uniq

# Salida
2024-04-25 INFO User logged in successfully.
2024-04-25 WARNING Disk usage exceeds 90%.
2024-04-26 ERROR Connection timed out.
2024-04-26 INFO Scheduled maintenance.

Este comando ordena el archivo log y lo canaliza a uniq, quitando líneas duplicadas.

3.  Contando ocurrencias de cada línea:

sort system.log | uniq -c

# Salida
2 2024-04-25 INFO User logged in successfully.
1 2024-04-25 WARNING Disk usage exceeds 90%.
2 2024-04-26 ERROR Connection timed out.
1 2024-04-26 INFO Scheduled maintenance.

Ordena las entradas de log y luego cuenta cada línea única. Según la salida, la línea '2024-04-25 INFO User logged in successfully.' apareció 2 veces en el archivo.

4.  Identificar entradas de log únicas:

sort system.log | uniq -u

# Salida

2024-04-25 WARNING Disk usage exceeds 90%.
2024-04-26 INFO Scheduled maintenance.

Este comando muestra las líneas que son únicas.

5.  Ordenar por nivel de by log level:

sort -k2 system.log

# Salida
2024-04-26 ERROR Connection timed out.
2024-04-26 ERROR Connection timed out.
2024-04-25 INFO User logged in successfully.
2024-04-25 INFO User logged in successfully.
2024-04-26 INFO Scheduled maintenance.
2024-04-25 WARNING Disk usage exceeds 90%.

Ordena las entradas basado en el segundo campo, el cual es el nivel de registro.

8.4. Gestionando procesos de Linux a través de la Línea de Comandos

Un proceso es una instancia de un programa en ejecución. Un proceso consiste de:

• Un espacio de dirección de la memora alojada.
• Estado del Proceso.
• Propiedades tales como propiedad, atributos de seguridad, y uso de recursos.

Un proceso también tiene un entorno que consiste de:

• Variables locales y globales
• El contexto de programación actual
• Recursos de sistema alojados, tales como puertos de red o descriptores de archivo.

Cuando ejecutes el comando ls -l, el sistema operativo crea un nuevo proceso para ejecutar el comando. El proceso tiene un ID, un estado, y ejecuta hasta que el comando se complete.

Entendiendo la creación de procesos y el ciclo de vida

En Ubuntu, todos los procesos se originan desde el proceso del sistema inicial llamado systemd, el cual el primer proceso comenzó por el kernel durante el arrnque.

El proceso systemd tiene un ID de proceso (PID) de 1 y es responsable por inicializar el sistema, comenzar y gestionar otros procesos, y manejar servicios de sistema. Todos los otros procesos en el sistema son descendientes de systemd.

Un proceso padre duplica su propio espacio de dirección (fork) para crear una nueva estructura de proceso. Cada nuevo proceso se le asigna un ID de proceso único (PID) para rastrear y por propósitos de seguridad. El PID y el ID del proceso del padre (PPID) son parte del nuevo entorno del proceso. Cualquier proceso puede crear un proceso hijo.

A través de la rutina de fork, un proceso hijo hereda identidades de seguridad, descriptores de archivo previos y actuales, puertos y privilegios de recursos, variables de entorno, y código de programa. Un proceso hijo podría ejecutar su propio código de programa.

Típicamente, un proceso padre se duerme mientras el proceso hijo se ejecuta, estableciendo una petición (wait) para ser notificado cuando el hijo se completa.

Al salir, el proceso hijo ya se cerrado o descartado sus recursos y entorno. El único recurso que permanece, conocido como un zombie, es una entrada en la table del proceso. El padre, señalado como despierto cuando el hijo termina, limpia la tabla del proceso de la entrada del hijo, de esa forma liberando el último recurso del proceso hijo. El proceso padre luego continua ejecutando su propio código de programa.

Entendiendo los estados del proceso

Los procesos en Linux asumen distintos estados durante sus ciclos de vida. El estado de un proceso indica que está haciendo actualmente el proceso y cómo interactúan con el sistema. La transición de procesos entre estados basados en su estado de ejecución y el algoritmo de programación del sistema.

Los procesos en un sistema Linux puede ser uno de los siguientes estados:

La transición de los procesos entre estos estados de las siguientes formas:

Cómo ver los procesos

Puedes usar el comando ps juntamente con una combinación de opciones para ver los procesos en un sistema Linux. El comando ps se usado para mostrar información sobre una selección de procesos activos. Por ejemplo, ps aux muestra todos los procesos que se ejecutan en el sistema.

zaira@zaira:~$ ps aux
# Salida
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.0 168140 11352 ?        Ss   May21   0:18 /sbin/init splash
root           2  0.0  0.0      0     0 ?        S    May21   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        I<   May21   0:00 [rcu_gp]
root           4  0.0  0.0      0     0 ?        I<   May21   0:00 [rcu_par_gp]
root           5  0.0  0.0      0     0 ?        I<   May21   0:00 [slub_flushwq]
root           6  0.0  0.0      0     0 ?        I<   May21   0:00 [netns]
root          11  0.0  0.0      0     0 ?        I<   May21   0:00 [mm_percpu_wq]
root          12  0.0  0.0      0     0 ?        I    May21   0:00 [rcu_tasks_kthread]
root          13  0.0  0.0      0     0 ?        I    May21   0:00 [rcu_tasks_rude_kthread]
*... output truncated ....*

La salida de arriba muestra un instantáneo de los procesos actuales en ejecución del sistema. Cada fila representa un proceso con las siguientes columnas:

1. USER: El usuario quien posee el proceso.
2. PID: El ID del proceso.
3. %CPU: El uso del CPU del proceso.
4. %MEM: El uso de memoria del proceso.
5. VSZ: El tamaño de la memoria virtual del proceso.
6. RSS: El tamaño del conjunto residente, que es la memoria física no intercambiada que una tarea ha usado.
7. TTY: La terminal de control del proceso. Un ? indica una terminal de sin control.
8. STAT: El estado del proceso.

• R: Running (ejecutando)
• I o S: Sueño interrumpible (esperando que un evento se complete)
• D: Sueño ininterrumpible (usualmente IO)
• T: Detenido (sea por una señal de control de un trabajo o porque está siendo trazado)
• Z: Zombie (terminado pero no repetido por su padre)
• Ss: Líder de sesión. Este es un proceso que ha comenzado una sesión, y es un líder de un grupo de procesos y puede controlar señales de la terminal. El primer S indica el estado de dormir, y el segundo s indica que es un líder de sesión.

1. START: El tiempo de comienzo o fecha del proceso.
2. TIME: El tiempo de CPU acumulativo.
3. COMMAND: El comando que comenzó el proceso.

Procesos de segundo y primer plano

En esta sección, aprenderás cómo puedes controlar trabajas al ejecutarlos en segundo o primer plano.

Un trabajo (job) es un proceso que comienza por una shell. Cuando ejecutas un comando en la terminal, se considera un trabajo. Un trabajo puede ejecutarse en primer o segundo plano.

Para demostrar el control, primero crearás 3 procesos y luego los ejecutarás en segundo plano. Después de eso, listarás los procesos y los alternarás entre primer y segundo plano. Verás cómo se los pone a dormir o salir completamente.

1. Crea tres procesos

Abre una terminal y comienza tres procesos de larga duración. usa el comando sleep, que mantiene el proceso ejecutándose por un número especificado de segundos.

# ejecuta el comando sleep por 300, 400, y 500 segundos
sleep 300 &
sleep 400 &
sleep 500 &

El & al final de cada comando mueve el proceso a segundo plano.

2.   Muestra trabajos en segundo plano

Usa el comando jobs para mostrar la lista de trabajos en segundo plano.

jobs

La salida debería verse así:

jobs
[1]   Running                 sleep 300 &
[2]-  Running                 sleep 400 &
[3]+  Running                 sleep 500 &

3.   Traer un trabajo en segundo plano a primer plano

Para traer un trabajo en segundo plano al primer plano, usa el comando fg seguido del número del trabajo. Por ejemplo, para traer el primer trabajo (sleep 300) al primer plano:

fg %1

Esto traerá el trabajo 1 al primer plano.

4.   Mueve el trabajo en primero plano nuevamente a segundo plano

Mientras el trabajo se ejecuta en el primer plano, puedes suspenderlo y llevarlo nuevamente al segundo plano al presionar Ctrl+Z para suspender el trabajo.

Un trabajo suspendido se verás de esta forma:

zaira@zaira:~$ fg %1
sleep 300

^Z
[1]+  Stopped                 sleep 300

zaira@zaira:~$ jobs
# trabajo suspendido 
[1]+  Stopped                 sleep 300
[2]   Running                 sleep 400 &
[3]-  Running                 sleep 500 &

Ahora usa el comando bg para reanudar el trabajo con ID 1 en el segundo plano.

# Presiona Ctrl+Z para suspender el trabajo de primer plano
# Luego, reanúdalo en segundo plano
bg %1

1. Muestra los trabajos nuevamente

jobs
[1]   Running                 sleep 300 &
[2]-  Running                 sleep 400 &
[3]+  Running                 sleep 500 &

En este ejercicio, vos:

• Comenzaste tres proceso en segundo plano usando comandos sleep.
• Usaste trabajos para mostrar la lista de trabajos en segundo plano.
• Trajiste un trabajo a primer plano con fg %job_number.
• Suspendiste el trabajo con Ctrl+Z y lo regresaste al segundo plano con bg %job_number.
• Usaste los trabajos nuevamente para verificar el estado de los trabajos en segundo plano.

Ahora sanes cómo controlar los trabajos.

Matando procesos

Es posible terminar un proceso que no responde o no querido usando el comando kill. El comando kill envía una señal a un ID de proceso, pidiéndole que termine.

Un número de opciones están disponibles con el comando kill.

# Opciones disponibles con kill

kill -l
 1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL     5) SIGTRAP
 6) SIGABRT     7) SIGBUS     8) SIGFPE     9) SIGKILL    10) SIGUSR1
11) SIGSEGV    12) SIGUSR2    13) SIGPIPE    14) SIGALRM    15) SIGTERM
16) SIGSTKFLT    17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) 
...terminated

Aquí hay algunos ejemplos del comando kill en Linux:

Matar un proceso por PID (ID del proceso):

 kill 1234

Este comando envía la señal SIGTERM predeterminada al proceso con un PID de 1234, solicitándole que termine.

Matar un proceso por nombre:

 pkill process_name

Este comando envía la señal SIGTERM predeterminada a todos los procesos con el nombre especificado.

Matar un proceso a la fuerza:

 kill -9 1234

Este comando envía la señal SIGKILL al proceso con el PID 1234, terminándolo a la fuerza.

Envía una señal específica a un proceso:

 kill -s SIGSTOP 1234

Este comando envía la señal SIGSTOP al proceso con el PID 1234, deteniéndolo.

Matar a todos los procesos que pertenecen a un usuario específico:

 pkill -u username

Este comando envía la señal SIGTERM predeterminada a todos los procesos que pertenecen al usuario especificado.

Estos ejemplos demuestran varias formas de usar el comando kill para gestionar procesos en un entorno de Linux.

Aquí esta la información sobre las opciones  y señales del comando kill de una forma tabular: Esta tabla resumen las opciones y señales más comunes del comando kill usados para gestionar los procesos.

8.5. Flujos de Entrada y Salida Estándar en Linux

Leer una entrada y escribir una entrada es una parte esencial de entender la línea de comandos y la programación de scripts. En Linux, cada proceso tiene tres flujos predeterminados:

Entrada Estándar (stdin): Este flujo se usa para entradas, típicamente desde el teclado. Cuando un programa lee desde el stdin, recibe datos ingresados por el usuario o redireccionado desde un archivo. Un descriptor de archivo es un identificador único que el sistema operativo asigna a un archivo abierto para mantener un rastro de archivos abiertos.

El descriptor de archivo para stdin es 0.

Salida Estándar (stdout): Este es el flujo de salida predeterminado donde un proceso escribe su salida. Por defecto, la salida estándar es la terminal. La salida también puede ser redireccionado a un archivo u otro programa. El descriptor de archivo para stdout es 1.

Error Estándar (stderr): Este es el flujo de error estándar donde un proceso escribe sus mensajes de error. Por defecto, el error estándar es la terminal, permitiendo que los mensajes de error sea visto inclusive si stdout es redireccionado. El descriptor de archivo para stderr es 2.

Redirección y Tuberías

Redirección: Puedes redireccionar el error y los flujos de salida a los archivos u otros comandos. Por ejemplo:

# Redireccionando stdout a un archivo
ls > output.txt

# Redireccionando stderr a un archivo
ls non_existent_directory 2> error.txt

# Redireccionando stdout y stderr a un archivo
ls non_existent_directory > all_output.txt 2>&1

En el último comando,

• ls non_existent_directory: lista los contenidos de una carpeta llamada non_existent_directory. Ya que esta carpeta no existe, ls generará un mensaje de error.
• > all_output.txt: El operador > redirecciona la salida estándar (stdout) del comando ls al archivo all_output.txt. Si el archivo no existe, será creado. Si existe, su contenido será sobrescrito.
• 2>&1:: Aquí, 2 representa el descriptor del archivo para el error estándar (stderr). &1 representa el descriptor del archivo para la salida estándar (stdout). El caracter & se usa para especificar que 1 no es el nombre del archivo sino un descriptor del archivo.

Así que, 2>&1 significa "redirecciona stderr (2) a donde sea que stdout (1) esté yendo actualmente", el cual en este caso es el archivo all_output.txt. Por lo tanto, la salida (si hay uno) y el mensaje de error de ls será escrito a all_output.txt.

Tuberías:

Puedes usar tuberías (|) para pasar la salida de un comando como la entrada a otro:

ls | grep image
# Salida
image-10.png
image-11.png
image-12.png
image-13.png
... Output truncated ...

8.6 Automatización en Linux – Automatizar Tareas con Tareas de Cron

Cron es una utilidad poderosa para programar trabajos que está disponible en sistemas operativos de Unix. Al configurar un cron, puedes configurar trabajos automatizados para ejecutar diariamente, mensualmente, u otro tiempo específico. Las capacidades de automatización provisto por cron juega un rol crucial en la administración de sistema de Linux.

El daemon crond (un tipo de programa de computadora que se ejecuta en segundo plano) permite la funcionalidad de cron. El cron lee el crontab (tablas de cron) para ejecutar scripts predefinidos.

Al usar una sintaxis específica, puedes configurar un trabajo cron para programar scripts u otros comandos para ejecutarlos automáticamente.

¿Qué son los trabajos cron en Linux?

Cualquier tarea que programes a través de crons se llama un trabajo de cron.

Ahora, veamos cómo los trabajos de cron funcionan.

Cómo controlar el acceso a los crons

Para usar los trabajos de cron, un administrador necesita permitir a los trabajos de cron que sean agregados para los usuarios en el archivo /etc/cron.allow.

Si obtienes un mensaje como este, significa que no tienes permiso para usar cron.

Para permitir a John que use crons, incluye su nombre en /etc/cron.allow. Crea el archivo si no existe. Esto permitirá a John que cree y edite trabajos de cron.

Los usuarios también se les puede denegar el acceso a trabajos de cron al ingresar sus nombres de usuario en el archivo /etc/cron.d/cron.deny.

Cómo agrega trabajos de cron en Linux

Primero, para usar los trabajos de cron, necesitarás verificar el estado del servicio de cron. Si cron no está instalado, puedes descargarlo fácilmente a través del gestor de paquetes. Solo usa esto para verificar:

# Check cron service on Linux system
sudo systemctl status cron.service

Sintaxis de trabajos de Cron

Los crontabs usan los siguientes argumentos para agregar y listar trabajos de cron:

• crontab -e: edita las entradas de crontab para agregar, eliminar, o editar trabajos de cron.
• crontab -l: listar todos los trabajos de cron para el usuario actual.
• crontab -u nombre-usuario -l: lista los crons de otro usuario.
• crontab -u nombre-usuario -e: edita los crons de otro usuario.

Cuando listas los crons y existen, verás algo como esto:

# Cron job example
* * * * * sh /path/to/script.sh

En el ejemplo de arriba,

• * representa minuto(s) hora(s) día(s) mes(es) semana(s), respectivamente. Ve los detalles de estos valores abajo:

• sh representa que el script es un script de bash y debería ser ejecutado desde /bin/bash.
• /path/to/script.sh especifica la ruta al script.

Abajo hay un resumen de la sintaxis de los trabajos de cron:

*   *   *   *   *  sh /path/to/script/script.sh
|   |   |   |   |              |
|   |   |   |   |      Comando o Script a ejecutarse        
|   |   |   |   |
|   |   |   |   |
|   |   |   |   |
|   |   |   | Día de la Semana(0-6)
|   |   |   |
|   |   | Mes del Año(1-12)
|   |   |
|   | Día del Mes(1-31)  
|   |
| Hora(0-23)  
|
Min(0-59)

Ejemplos de Trabajos de Cron

Abajo hay algunos ejemplos de programación de trabajos de cron.

No hay problema si no logras comprender todo esto de una vez. Puedes practicar y generar cronogramas con el sitio web crontab guru.

Cómo configurar un trabajo cron

En esta sección, veremos un ejemplo de cómo programar un script sencillo con un trabajo cron.

1. Crea un script llamado date-script.sh el cual imprime la fecha y hora del sistema y lo adjunta a un archivo. El script se muestra abajo:

#!/bin/bash

echo `date` >> date-out.txt

2.   Haz que el script sea ejecutable al darle derechos de ejecución.

chmod 775 date-script.sh

3.   Agrega el script en el crontab usando crontab -e.

Aquí, lo hemos programado para que se ejecute por minuto.

*/1 * * * * /bin/sh /root/date-script.sh

4.   Verifica la salida del archivo date-out.txt. Según el script, la fecha del sistema debería ser impreso a este archivo cada minuto.

cat date-out.txt
# Salida
Wed 26 Jun 16:59:33 PKT 2024
Wed 26 Jun 17:00:01 PKT 2024
Wed 26 Jun 17:01:01 PKT 2024
Wed 26 Jun 17:02:01 PKT 2024
Wed 26 Jun 17:03:01 PKT 2024
Wed 26 Jun 17:04:01 PKT 2024
Wed 26 Jun 17:05:01 PKT 2024
Wed 26 Jun 17:06:01 PKT 2024
Wed 26 Jun 17:07:01 PKT 2024

Cómo solucionar problemas de crons

Los crons son realmente útiles, pero no podrían funcionar siempre como se espera. Afortunadamente, hay algunos métodos efectivos que puedes usar para solucionar problemas.

1. Verifica la programación.

Primero, puedes intentar verificar la programación que fue hecho para el cron. Puedes hacer eso con la sintaxis que viste en las secciones de arriba.

2. Verificar archivos log de cron.

Primero, necesita verificar si el con se ha ejecutado en el tiempo previsto o no. En Ubuntu, puedes verificarlo desde los logs de cron localizado en /var/log/syslog.

Si hay una entrada en estos logs en el tiempo correcto, significa que el cron se ha ejecutado según la planificación que estableciste.

Abajo están los logs de nuestro ejemplo de un trabajo de cron. Fíjate que la primer columna el cual muestra la marca de tiempo. La ruta del script también se menciona al final de la línea. Línea #1, 3, y 5 muestra que el script se ejecutó como se esperaba.

1 Jun 26 17:02:01 zaira-ThinkPad CRON[27834]: (zaira) CMD (/bin/sh /home/zaira/date-script.sh)
2 Jun 26 17:02:02 zaira-ThinkPad systemd[2094]: Started Tracker metadata extractor.
3 Jun 26 17:03:01 zaira-ThinkPad CRON[28255]: (zaira) CMD (/bin/sh /home/zaira/date-script.sh)
4 Jun 26 17:03:02 zaira-ThinkPad systemd[2094]: Started Tracker metadata extractor.
5 Jun 26 17:04:01 zaira-ThinkPad CRON[28538]: (zaira) CMD (/bin/sh /home/zaira/date-script.sh)

3. Redireccionar la salida del cron a un archivo.

Puedes redireccionar una salida del cron a un archivo y verificar si el archivo tiene algún error posible.

# Redirige la salida de cron a un archivo
* * * * * sh /path/to/script.sh &> log_file.log

8.7. Conceptos Básicos de Redes de Linux

Linux ofrece un número de comandos para ver la información relacionado a la red. En esta sección discutiremos brevemente algunos de los comandos.

Ver interfaces de red con ifconfig

El comando ifconfig provee información sobre las interfaces de red. Aquí hay un ejemplo de salida:

ifconfig

# Salida
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.100  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::a00:27ff:fe4e:66a1  prefixlen 64  scopeid 0x20<link>
        ether 08:00:27:4e:66:a1  txqueuelen 1000  (Ethernet)
        RX packets 1024  bytes 654321 (654.3 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 512  bytes 123456 (123.4 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 256  bytes 20480 (20.4 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 256  bytes 20480 (20.4 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

La salida del comando ifconfig muestra las interfaces de red configurados en el sistema, juntamente con detalles tales como direcciones IP, direcciones MAC, estadísticas de paquetes, y más.

Estas interfaces pueden ser dispositivos físicos o virtuales.

Para extraer las direcciones IPv4 y IPv6, puedes usar ip -4 addr y ip -6 addr, respectivamente.

Ver la actividad de red con netstat

El comando netstat muestra las estadísticas y la actividad de la red al dar la siguiente información:

Aquí hay algunos ejemplos al usar el comando netstat en la línea de comandos:

Muestra todos los sockets de escucha y no escucha:

 netstat -a

Muestra solamente los puertos en escucha:

 netstat -l

Muestra las estadísticas de red:

 netstat -s

Muestra la tabla de enrutamiento:

 netstat -r

Muestra las conexiones TCP:

 netstat -t

Muestra las conexiones UDP:

 netstat -u

Muestra las interfaces de red:

 netstat -i

Muestra el PID y los nombres de programa para las conexiones:

 netstat -p

Muestra las estadísticas para un protocolo específico (por ejemplo, TCP):

 netstat -st

Mostrar información extendida:

netstat -e

Verifica la conectividad de red entre dos dispositivos usando ping

ping se usa para probar la conectividad de red entre dos dispositivos. Envía paquetes ICMP al dispositivo objetivo y espera una respuesta.

ping google.com

ping prueba si obtienes una respuesta sin recibir un tiempo de espera.

ping google.com
PING google.com (142.250.181.46) 56(84) bytes of data.
64 bytes from fjr04s06-in-f14.1e100.net (142.250.181.46): icmp_seq=1 ttl=60 time=78.3 ms
64 bytes from fjr04s06-in-f14.1e100.net (142.250.181.46): icmp_seq=2 ttl=60 time=141 ms
64 bytes from fjr04s06-in-f14.1e100.net (142.250.181.46): icmp_seq=3 ttl=60 time=205 ms
64 bytes from fjr04s06-in-f14.1e100.net (142.250.181.46): icmp_seq=4 ttl=60 time=100 ms
^C
--- google.com ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3001ms
rtt min/avg/max/mdev = 78.308/131.053/204.783/48.152 ms

Puedes detener la respuesta con Ctrl + C.

Probando recursos con el comando curl

El comando curl significa "URL del cliente". Se usa para transferir datos a un o de un servidor. También puede ser usado para probar recursos de una API lo que ayuda en solucionar errores de sistema y de aplicaciones.

Como un ejemplo, puedes usar http://www.official-joke-api.appspot.com/ para experimentar con el comando curl.

• El comando curl sin ninguna opción usa el método GET por defecto.

curl http://www.official-joke-api.appspot.com/random_joke
{"type":"general",
"setup":"What did the fish say when it hit the wall?","punchline":"Dam.","id":1}

• curl -o guarda la salida al archivo mencionado.

curl -o random_joke.json http://www.official-joke-api.appspot.com/random_joke
# saves the output to random_joke.json

• curl -I busca solamente las cabeceras.

curl -I http://www.official-joke-api.appspot.com/random_joke
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Vary: Accept-Encoding
X-Powered-By: Express
Access-Control-Allow-Origin: *
ETag: W/"71-NaOSpKuq8ChoxdHD24M0lrA+JXA"
X-Cloud-Trace-Context: 2653a86b36b8b131df37716f8b2dd44f
Content-Length: 113
Date: Thu, 06 Jun 2024 10:11:50 GMT
Server: Google Frontend

8.8. Solucionando problemas de Linux: Herramientas y Técnicas

Reporte de actividad del Sistema con sar

El comando sar en Linux es una herramienta poderosa para recolectar, reportar, y guardar información de estadísticas del sistema. Es parte del paquete sysstat y es ampliamente usado para monitorear el rendimiento del sistema con el tiempo.

Para usar sar primero necesitas instalar sysstat usando sudo apt install sysstat.

Una vez instalado, comienza el servicio con sudo systemctl start sysstat.

Verifica el estado con sudo systemctl status sysstat.

Una vez que el estado esté activo, el sistema comenzará a recolectar varias estadísticas que puedes usar para acceder y analizar datos históricos. Veremos eso en detalle pronto.

La sintaxis del comando sar es como sigue:

sar [opciones] [intervalo] [cuenta]

Por ejemplo, sar -u 1 3 mostrará el uso de estadísticas del CPU por segundo tres veces.

sar -u 1 3
# Salida
Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

19:09:26        CPU     %user     %nice   %system   %iowait    %steal     %idle
19:09:27        all      3.78      0.00      2.18      0.08      0.00     93.96
19:09:28        all      4.02      0.00      2.01      0.08      0.00     93.89
19:09:29        all      6.89      0.00      2.10      0.00      0.00     91.01
Average:        all      4.89      0.00      2.10      0.06      0.00     92.95

Aquí hay algunos de los casos de uso comunes y ejemplos de cómo usar el comando sar.

sar puede ser usado para una variedad de propósitos:

1. Uso de Memoria

Para verificar el uso de memoria (libre y usado), usa:

sar -r 1 3

Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

19:10:46    kbmemfree   kbavail kbmemused  %memused kbbuffers  kbcached  kbcommit   %commit  kbactive   kbinact   kbdirty
19:10:47      4600104   8934352   5502124     36.32    375844   4158352  15532012     65.99   6830564   2481260       264
19:10:48      4644668   8978940   5450252     35.98    375852   4165648  15549184     66.06   6776388   2481284        36
19:10:49      4646548   8980860   5448328     35.97    375860   4165648  15549224     66.06   6774368   2481292       116
Average:      4630440   8964717   5466901     36.09    375852   4163216  15543473     66.04   6793773   2481279       139

Este comando muestra las estadísticas de memoria cada segundo tres veces.

2. Utilización del espacio de intercambio (Swap)

Para ver las estadísticas del uso del espacio de swap, usa:

sar -S 1 3

sar -S 1 3
Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

19:11:20    kbswpfree kbswpused  %swpused  kbswpcad   %swpcad
19:11:21      8388604         0      0.00         0      0.00
19:11:22      8388604         0      0.00         0      0.00
19:11:23      8388604         0      0.00         0      0.00
Average:      8388604         0      0.00         0      0.00

Este comando ayuda en monitorear el uso de swap, lo cual es crucial para los sistemas que quedan sin espacio de memoria física.

3. Carga de dispositivos I/O

Para reportar actividad de dispositivos de bloque y particiones de dispositivos de bloque:

sar -d 1 3

Este comando provee estadísticas detallados sobre las transferencias de datos de los dispositivos de bloque, y es útil para diagnosticar cuellos de botella de I/O.

5. Estadísticas de Red

Para ver las estadísticas de red, como el número de paquetes recibidos (transmitidos) por la interfaz de red:

sar -n DEV 1 3
# -n DEV le dice a sar que reporte interfaces de dispositivos de red
sar -n DEV 1 3
Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

19:12:47        IFACE   rxpck/s   txpck/s    rxkB/s    txkB/s   rxcmp/s   txcmp/s  rxmcst/s   %ifutil
19:12:48           lo      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00
19:12:48       enp2s0      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00
19:12:48       wlp3s0     10.00      3.00      1.83      0.37      0.00      0.00      0.00      0.00
19:12:48    br-5129d04f972f      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00
.
.
.

Average:        IFACE   rxpck/s   txpck/s    rxkB/s    txkB/s   rxcmp/s   txcmp/s  rxmcst/s   %ifutil
Average:           lo      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00
Average:       enp2s0      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00
...output truncated...

Esto muestra las estadísticas de red cada segundo por tres segundos, lo que ayuda en monitorear el tráfico de red.

6. Datos históricos

Recuerda que instalamos el paquete sysstat previamente  y ejecutamos el servicio. Sigue los pasos de abajo para permitir y acceder a los datos históricos.

Permitir recolección de datos: Edita el archivo de configuración sysstat para permitir la recolección de datos.

 sudo nano /etc/default/sysstat

Cambia ENABLED="false" a ENABLED="true".

 vim /etc/default/sysstat
 #
 # Configuraciones predeterminadas para los archivos /etc/init.d/sysstat, /etc/cron.d/sysstat
 # y /etc/cron.daily/sysstat
 #

 # ¿Debería sadc recolectar información de la actividad del sistema? Valores válidos
 # son "true" y "false". Por favor no pongas otros valores, serán
 # anulados por debconf!
 ENABLED="true"

Configura el intervalo de recolección de datos: Edita la configuración del trabajo de cron para poner el intervalo de recolección de datos.

 sudo nano /etc/cron.d/sysstat

Por defecto, recolecta datos cada 10 minutos. Puedes ajustar el intervalo al modificar la planificación del trabajo de cron. Los archivos relevantes irán a la carpeta /var/log/sysstat.

Ver los datos históricos: Usa el comando sar para ver los datos históricos. Por ejemplo, para ver el uso del CPU para el día actual:

 sar -u

Para ver los datos desde una fecha específica:

 sar -u -f /var/log/sysstat/sa<DD>

Reemplaza <DD> con el día del mes con el cual quieres ver los datos.

En el comando de abajo, /var/log/sysstat/sa04 provee estadísticas para el cuarto día del mes actual.

sar -u -f /var/log/sysstat/sa04
Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

15:20:49     LINUX RESTART    (12 CPU)

16:13:30     LINUX RESTART    (12 CPU)

18:16:00        CPU     %user     %nice   %system   %iowait    %steal     %idle
18:16:01        all      0.25      0.00      0.67      0.08      0.00     99.00
Average:        all      0.25      0.00      0.67      0.08      0.00     99.00

7. Interrupciones de la CPU en tiempo real

Para observar interrupciones en tiempo real por segundo servido por la CPU, usa este comando:

sar -I SUM 1 3

# Salida
Linux 6.5.0-28-generic (zaira-ThinkPad)     04/06/24     _x86_64_    (12 CPU)

19:14:22         INTR    intr/s
19:14:23          sum   5784.00
19:14:24          sum   5694.00
19:14:25          sum   5795.00
Average:          sum   5757.67

Este comando ayuda a monitorear con cuanta frecuencia la CPU maneja las interrupciones, lo cual puede ser crucial para ajuste de rendimiento en tiempo real.

Estos ejemplos ilustran cómo puedes usar sar para monitorear varios aspectos del rendimiento de sistema. El uso regular de sar puede ayudar a identificar los cuellos de botella del sistema y asegurar que las aplicaciones se mantenga ejecutando de forma eficiente.

8.9. Estrategia General para Solucionar Problemas para los Servidores

¿Por qué necesitamos entender sobre monitoreo?

El monitoreo de sistema es un aspecto importante de la administración de sistema. Las aplicaciones críticas demandan un alto nivel de proactividad para prevenir fallas y reducir el impacto de cortes.

Linux ofrece herramientas muy potentes para medir la salud del sistema. En esta sección, aprenderás sobre los varios métodos disponibles para verificar la salud del sistema e identificar los cuellos de botella.

Encontrar el promedio de carga y tiempo de actividad del sistema

Los reinicios de sistema podría ocurrir lo cual puede a veces arruinar algunas configuraciones. Para verificar cuánto tiempo la máquina estuvo activa, usa el comando: uptime. Además del tiempo de actividad, el comando también muestra el promedio de carga.

[user@host ~]$ uptime 19:15:00 up 1:04, 0 users, load average: 2.92, 4.48, 5.20

El promedio de carga es la carga del sistema durante los minutos 1, 5 y 15. Un vistazo rápido indica si la carga de sistema está en incremento o disminuyendo con el tiempo.

Nota: la cola de CPU ideal es 0. Esto es posible solamente cuando no hay colas de espera para la CPU.

Cada carga de CPU puede ser calculado al dividir el promedio de carga con el número total de CPUs disponibles.

Para encontrar el número de CPUs, usa el comando lscpu.

lscpu
# Salida
Architecture:            x86_64
  CPU op-mode(s):        32-bit, 64-bit
  Address sizes:         48 bits physical, 48 bits virtual
  Byte Order:            Little Endian
CPU(s):                  12
  On-line CPU(s) list:   0-11
.
.
.
Salida omitido

Si el promedio de carga parece incrementar y no se va para abajo, los CPUs están sobrecargados. Hay algún proceso que está estancado o hay fuga de memoria.

Calculando memoria libre

A veces, el alto uso de memoria podría causar problemas. Para verificar la memoria disponible y la memoria en uso, usa el comando free.

free -mh
# Salida
               total        used        free      shared  buff/cache   available
Mem:            14Gi       3.5Gi       7.7Gi       109Mi       3.2Gi        10Gi
Swap:          8.0Gi          0B       8.0Gi

Calculando el espacio de disco

Para asegurarse que el sistema está saludable, no te olvides sobre el espacio de disco. Para listar todos los puntos de montaje disponible y su porcentaje usado respectivamente, usa el comando de abajo. Idealmente, los espacios de disco utilizados no deberían exceder un 80%.

El comando df provee espacios de disco detallados.

df -h
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           1.5G  2.4M  1.5G   1% /run
/dev/nvme0n1p2  103G   34G   65G  35% /
tmpfs           7.3G   42M  7.2G   1% /dev/shm
tmpfs           5.0M  4.0K  5.0M   1% /run/lock
efivarfs        246K   93K  149K  39% /sys/firmware/efi/efivars
/dev/nvme0n1p3  130G   47G   77G  39% /home
/dev/nvme0n1p1  511M  6.1M  505M   2% /boot/efi
tmpfs           1.5G  140K  1.5G   1% /run/user/1000

Determinando los estados de proceso

Los estados de proceso pueden ser monitoreados para ver cualquier proceso estancado con un alto uso de memoria o de CPU.

Vimos anteriormente que el comando ps nos da información útil sobre un proceso. Pega un vistazo a las columnas CPU y MEM.

[user@host ~]$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
 runner         1  0.1  0.0 1535464 15576 ?       S  19:18   0:00 /inject/init
 runner        14  0.0  0.0  21484  3836 pts/0    S   19:21   0:00 bash --norc
 runner        22  0.0  0.0  37380  3176 pts/0    R+   19:23   0:00 ps aux

Monitoreo del sistema en tiempo real

El monitoreo en tiempo real provee una ventana en el estado del sistema en tiempo real.

Una utilidad que puedes usar para hacer esto es el comando top.

El comando de arriba muestra una vista dinámica de los procesos del sistema, mostrando un resumen de la cabecera seguido de un proceso o una lista de hilos. A diferencia de su contraparte estática ps, top refresca continuamente las estadísticas del sistema.

Con top, puedes ver detalles bien organizados en una ventana compacta. Hay un número de argumentos, atajos y métodos resaltados que vienen junto con top.

También puedes matar procesos usando top. Para eso, presiona k y luego ingresa el id del proceso.

Interpretando archivos log

Los archivos log de sistema y de aplicaciones conllevan muchísima información sobre el cual el sistema está pasando. Contienen información útil y códigos de error que apuntan a errores. Si buscas códigos de errores en los archivos log, la identificación de problemas y el tiempo de rectificación pueden ser reducidos enormemente.

Análisis de puertos de Red

El aspecto de red no debería ser ignorado ya que los fallos de red son comunes y podrían impactar en el sistema y en el flujo de tráfico. Problemas de red comunes incluyen agotamiento de puerto, asfixia de puerto, recursos sin liberarse, etcétera.

Para identificar tales problemas, necesitamos entender los estados de puerto.

Algunos de los estados de puertos son explicados de forma breve aquí:

Exploremos cómo podemos analizar la información relacionado a los puertos en Linux.

Rangos de Puerto: Los rangos de puerto son definidos en el sistema, y los rangos pueden ser aumentados/disminuidos respectivamente. En el fragmento de abajo, el rango es desde 15000 a 65000, lo cual hace un total de 50000 (65000 - 15000) de puertos disponibles. Si los puertos utilizados están alcanzando o excediendo este límite, entonces hay un problema.

[user@host ~]$ /sbin/sysctl net.ipv4.ip_local_port_range
net.ipv4.ip_local_port_range = 15000    65000

El error reportado en los archivos log en tales casos puede ser Failed to bind to port o Too many connections.

Identificando pérdidas de paquetes

En el monitoreo de sistema, necesitamos asegurarnos que la comunicación entrante y saliente está intacto.

Un comando útil es ping. ping llega al sistema destinatario y trae de vuelta la respuesta. Fíjate que las últimas pocas líneas de estadísticas que muestran el porcentaje y tiempo de la pérdida de los paquetes.

# ping IP destinatario
[user@host ~]$ ping 10.13.6.113
 PING 10.13.6.141 (10.13.6.141) 56(84) bytes of data.
 64 bytes from 10.13.6.113: icmp_seq=1 ttl=128 time=0.652 ms
 64 bytes from 10.13.6.113: icmp_seq=2 ttl=128 time=0.593 ms
 64 bytes from 10.13.6.113: icmp_seq=3 ttl=128 time=0.478 ms
 64 bytes from 10.13.6.113: icmp_seq=4 ttl=128 time=0.384 ms
 64 bytes from 10.13.6.113: icmp_seq=5 ttl=128 time=0.432 ms
 64 bytes from 10.13.6.113: icmp_seq=6 ttl=128 time=0.747 ms
 64 bytes from 10.13.6.113: icmp_seq=7 ttl=128 time=0.379 ms
 ^C
 --- 10.13.6.113 ping statistics ---
 7 packets transmitted, 7 received,0% packet loss, time 6001ms
 rtt min/avg/max/mdev = 0.379/0.523/0.747/0.134 ms

Los paquetes también pueden ser capturados en tiempo de ejecución usando tcpdump. Veremos esto más adelante.

Reuniendo estadísticas para problemas críticos

Siempre es una buena práctica reunir ciertas estadísticas que sería útil para identificar la causa raíz luego. Usualmente, después del reinicio del sistema o del reinicio de los servicios, perdemos los instantáneos y archivos log previos del sistema.

Abajo hay algunos de los métodos para capturar el instantáneo del sistema.

• Copia de seguridad de los Archivos Log

Antes de hacer cualquier cambio, copia los archivos log a otra ubicación. Esto es crucial para entender en qué condición estaba el sistema durante el tiempo del problema. A veces los archivos de registro son la única ventana para ver los estados anteriores del sistema ya que se pierden otras estadísticas de tiempo de ejecución.

• TCP Dump

Tcpdump es una utilidad de línea de comandos que te permiten capturar y analizar tráfico de red entrante y saliente. Es mayormente usado para ayudar a solucionar problemas de red. Si sientes que el tráfico de sistema está siendo impactado, toma a tcpdump como sigue:

sudo tcpdump -i any -w

# Donde,
# -i any captura tráfico de todas las interfaces
# -w especifica la salida del nombre de archivo

# Para el comando después de unos pocos mins ya que el tamaño del archivo podría incrementar
# usa la extensión de archivo como .pcap

Una vez que el tcpdump es capturado, puedes usar herramientas como Wireshark para analizar el tráfico de forma visual.

Conclusión

Gracias por leer el libro hasta el final. Si lo encontraste útil, considera compartirlo con los demás.

Este libro no termina aquí. Continuaré mejorándolo y agregando nuevos materiales en el futuro. Si encontraste algún problema o te gustaría sugerir alguna mejora, no dudes en abrir una PR / Issue.

¡Manténte conectado y continúa tu jornada de aprendizaje!

Tu jornada con Linux no tiene que terminar aquí. Manténte contectado y lleva tus habilidades al siguiente nivel:

1. Sígueme en las redes sociales:
2. X: Comparto contenido útil de forma corta allí. Mi DMs están siempre abiertos.
3. LinkedIn: Comparto artículos y posts sobre tech allí. Deja una recomendación en LinkedIn y apóyame en habilidades relevantes.
4. Obtén acceso a contenido exclusivo: Para una ayuda personal y contenido exclusivo ve aquí.

Mis artículos y libros, como este, son parte de mi misión para aumentar el acceso a contenido de calidad para todos. Este libro también estará abierto para ser traducido a otros idiomas. Cada pieza toma mucho tiempo y esfuerzo para escribir. Este libro estará gratuito, para siempre. Si has disfrutado mi trabajo y quieres mantenerme motivado, considera comprarme un café.

Gracias una vez más y, ¡feliz aprendizaje!

Quizás ya comprendas lo importante que puede ser una buena VPN para mantener la seguridad y privacidad de tus comunicaciones móviles.

Ya sea que necesites usar tu teléfono para realizar operaciones bancarias a través de una conexión WIFI del aeropuerto o de una cafetería pública, o estás preocupado porque alguna persona equivocada esté escuchando tus interacciones en línea, la encriptación en túnel que brinda una buena VPN puede ser invaluable.

El truco, sin embargo, es encontrar una VPN que sea realmente "buena" - y una que sea conveniente y asequible.

Existen muchos servicios de VPN, y configurar una VPN en tu teléfono o laptop suele ser bastante sencillo.

Pero algunos servicios vienen con dos desventajas potenciales: son muy costosos, con pagos que promedian alrededor de los $10 mensuales, y nunca puedes estar 100% seguro que no estén (ya sea accidentalmente o a propósito) filtrando o haciendo un mal uso de tus datos.

Además, VPNs económicas a menudo limitan el uso de tus datos y el número de dispositivos que puedas conectar.

Si te gusta ver versiones en vídeo de tutoriales para complementar tu aprendizaje, no dudes en seguirlos aquí:

Lo que ofrece WireGuard

Pero si de todos modos tienes un servidor Linux basado en la nube ejecutándose, construir una VPN en WireGuard puede ser una forma sencilla y gratuita para agregar algunas medidas serias, como seguridad y privacidad sin compromisos para tu vida.

Si planeas limitar la VPN para algunos dispositivos de tu propiedad y de algunos amigos, probablemente nunca jamás notarás una carga de recursos adicionales en tu servidor. Incluso si has activado y pagado por una instancia reservada en AWS EC2 tw.micro, los costos anuales deberían seguir siendo significativamente más baratos que los de la mayoría de las VPN comerciales. Y, como bono adicional, tendrás completo control sobre tus datos.

Ahora te voy a mostrar cómo todo eso debería funcionar usando un software de código abierto en WireGuard en un Servidor de Linux Ubuntu.

¿Porqué WireGuard? Porque es realmente fácil de usar, está diseñado para ser particularmente resistente a ataques, y es muy bueno en lo que hace que fue recientemente incorporado dentro del propio kernel de Linux.

El trabajo actual para que esto ocurra realmente tomará sólo cinco minutos - o menos. Una vez dicho esto, planear las cosas, solucionar los problemas de configuración inesperados y, si es necesario, lanzar un nuevo servidor podría agregar tiempo significante al proyecto.

¿Cómo configurar el Entorno?

Primero que nada, necesitas tener abierto el puerto UDP 51820 en cualquier firewall que estés utilizando. Así es como vería el grupo de seguridad asociado con una instancia AWS EC2:

Ahora, en el servidor de Linux, usando un comando de sudo, empezaremos instalando WireGuard y los paquetes de resolvconf.

Técnicamente o probablemente no necesitemos resolvconf aquí, pero como eso es lo que necesitarías si quisieras configurar una máquina virtual de Linux, como un cliente de WireGuard, pensé agregarlo aquí.

¿Cómo generar Claves de Cifrado?

El comando wg genkey genera una nueva clave de cifrado privada y lo guarda como un archivo en el directorio /etc/wireguard. Este directorio fue automáticamente creado cuándo instalamos WireGuard.

El comando chmod establece los permisos de restricción apropiados para ese archivo de clave privada.

Como todo en Linux, hay otras manera de realizar esto, pero solo asegúrate de hacerlo bien.

A continuación, usaremos el valor de nuestra clave privada para generar una clave pública correspondiente, la cual también se guardará en el directorio /etc/wireguard. El objetivo es agregar la clave pública del servidor a la configuración de WireGuard en todos los dispositivos cliente que usaremos, y luego agregar las claves públicas de esos clientes a la configuración del servidor aquí.

Las claves privadas nunca deben salir de las máquinas para las que se crean, y siempre deben protegerse cuidadosamente.

Cómo configurar el Servidor de WireGuard

Ya estamos listos para crear un archivo de configuración del servidor. Siguiendo la convención, nombraré el archivo wg0.conf, pero puedes darle el nombre que desees. También puedes tener múltiples configuraciones (con diferentes nombres de archivo) existiendo al mismo tiempo.

Así se verá nuestra configuración:

Ten en cuenta que este archivo tiene tres secciones: una Interfaz y dos pares. La sección Interfaz define la dirección de red privada NAT que usará nuestro servidor. Esta es la dirección privada a la que se conectarán los clientes, después de solicitar primero el acceso a través de la dirección IP pública del servidor, por supuesto.

No es necesario que sigas mi ejemplo de dirección, siempre y cuando uses un rango de IP privada válido que no se superponga con ningún bloque de red utilizado por tu servidor o cliente.

En concordancia con la regla del grupo de seguridad UDP que configuré anteriormente en AWS, estoy definiendo el ListenPort como 51820. Sin embargo, podría elegir un puerto diferente para agregar un poco más de seguridad si lo desearas.

Finalmente, pegaría la Clave Privada del servidor como valor de PrivateKey para que WireGuard pueda autenticar las solicitudes entrantes de los clientes.

La primera sección peer no contiene nada más que la clave pública y la dirección IP privada asignada de un cliente. La segunda sección peer hace lo mismo para una segunda máquina cliente.

Obtener las claves públicas de los clientes es la tarea más manual en toda esta configuración. Pero, como se trata de tu propia VPN, normalmente puedes encontrar una forma de copiar y pegar directamente en la configuración de tu servidor para no tener que escribir todo dolorosamente a mano.

Eso debería ser todo. Usaré el comando wg-quick para activar la VPN. up le indica a WireGuard que lea la configuración wg0.conf que acabamos de crear y la use para construir una nueva interfaz VPN.

Ejecutar wg nos mostrará que funcionó. Finalmente, ejecutaré systemctl enable <nombre_del_servicio> para indicarle a Linux que cargue esta interfaz WireGuard automáticamente cada vez que el servidor se reinicie.

Cómo configurar el Cliente WireGuard

Eso es todo lo que necesitaremos del lado del servidor. Configurar tu dispositivo cliente con WireGuard será mucho más fácil o más o menos lo mismo.

¿A qué me refiero con más o menos lo mismo? Bueno, si estás trabajando con Windows, macOS, Android o iOS, entonces hay enlaces a aplicaciones GUI disponibles en esta página . Esas aplicaciones generarán pares de claves para ti. Sólo necesitarás ingresar la dirección IP o el dominio del servidor y su clave pública. Luego, tomarás la clave pública del cliente y la agregarás al archivo wg0.conf del servidor de la forma que te mostré anteriormente.

Sin embargo, si se trata de un cliente de PC o portátil Linux que deseas agregar, entonces es un poco más complicado. Básicamente, seguirás todos los pasos que viste para la configuración del servidor, incluida la generación de claves. Incluso crearás un archivo de configuración llamado wg0.conf (si ese es el nombre que te gusta). Pero así es como debería verse ese archivo de configuración:

[Interface]
# La dirección que tu computadora usará en el VPN
Address = 10.5.5.2/32
DNS = 8.8.8.8
# Carga tu clave privada desde el archivo
PostUp = wg set %i private-key /etc/wireguard/privatekey
# También hace ping al servidor vpn para asegurarse que el túnel se inicializó
PostUp = ping -c1 10.47.47.1
[Peer]
# La clave pública de wireguard del servidor VPN
PublicKey = your_key
# Dirección de la IP Pública de tu servidor VPN (USA EL TUYO!)
Endpoint = 54.160.21.183:51820
# 10.0.0.0/24 es el subnet VPN
AllowedIPs = 10.47.47.0/24
# PersistentKeepalive = 25

La sección Interface representa esta vez la máquina cliente, mientras que la sección Peer más abajo se refiere al servidor. Comencemos con Interface. La dirección IP privada debe coincidir con la dirección que le das a este cliente específico en la configuración del servidor.

Si necesitas que tu cliente evite un servidor DNS local, puedes especificar un servidor DNS personalizado allí. Este es el que proporciona Google.

En lugar de escribir tu clave privada local en tu archivo de configuración de la forma en que lo hicimos en el servidor, puedes decirle a WireGuard que lea el archivo privateKey cada vez que se cargue. Probablemente sea una práctica recomendada de seguridad, y también podríamos haberlo hecho en el servidor. Finalmente, el script de configuración probará nuestra conexión con el comando PostUp ping.

La configuración Peer - o del servidor - requiere la clave pública del servidor, la cual se agrega aquí.

El Endpoint es donde le dices a WireGuard dónde encontrar el servidor. ¡Nada funcionará sin esto! Aquí se requiere la IP pública del servidor, o su nombre de dominio, seguido del puerto que has elegido. Una vez más, 51820 es el predeterminado de WireGuard.

Finalmente, la configuración de AllowedIPs define el rango de direcciones de red que usarás, y el valor opcional PersistentKeepalive puede evitar que se pierdan las conexiones.

Inicias WireGuard en el cliente exactamente de la misma manera que lo hiciste en el servidor, usando wg-quick up wg0. Sin embargo, una vez más, todos esos pasos sólo serán necesarios para clientes Linux. Puedes usar las aplicaciones para otras plataformas.

Resumen

Y listo, eso es todo. Tal y como dije, una VPN funcional en unos cinco minutos de trabajo. Ahora no tienes excusa para proteger tu privacidad en línea y asegurar tus comunicaciones.

Para obtener más información sobre tecnología, suscríbete a mi canal de YouTube y, cuando tengas un momento, echa un vistazo a los numerosos libros y cursos de Linux, seguridad, análisis de datos y AWS disponibles en mi sitio web bootstrap-it.com.

En Linux, la automatización de procesos se basa fuertemente en la programación de intérprete de comandos (en inglés Shell). Esto involucra el crear un archivo conteniendo una serie de comandos que pueden ser ejecutados juntos.

En este artículo, empezaremos con lo básico de programación de bash el cual incluye variables, comandos, entradas/salidas, y depuración. También veremos ejemplos de cada uno a lo largo.

¡Comencemos! 🚀

Tabla de Contenidos

1. Pre-requisitos

2. Introducción

• Definición de programación de Bash
• Ventajas de la programación de Bash
• Vista general de la terminal Bash y la interfaz de línea de comandos

3. Cómo empezar con la programación de Bash

• Cómo ejecutar comandos de Bash desde la Línea de Comandos
• Cómo crear y ejecutar scripts de Bash

4. Lo esencial sobre Programación de Bash

• Comentarios en programación de bash
• Variables y tipos de datos en Bash
• Convenciones de nomenclatura de variables
• Entradas y salidas en scripts de Bash
• Comandos básicos de Bash (echo, read, etc.)
• Declaraciones condicionales (if/else)

5. Bucles y ramificación en Bash

• Bucle While
• Bucle For
• Declaraciones Case

6. Cómo programar Scripts usando cron

7. Cómo depurar y solucionar problemas de scripts de Bash

8. Conclusión

• Recursos para aprender más sobre programación de Bash

Pre-requisitos

Para seguir este tutorial, deberías tener los siguientes accesos:

• Una versión en ejecución de Linux con acceso a la línea de comandos.

Si no tienes Linux instalado o recién estás empezando, puedes fácilmente acceder a la línea de comandos de Linux a través de Replit. Replit es un IDE basado en un navegador donde puedes acceder a la shell de bash en unos pocos minutos.

También puedes instalar Linux sobre tu sistema de Windows usando WSL (Subsistema de Windows para Linux - Windows Subsystem for Linux).

Introducción

Definición de programación de Bash

Un script de Bash es un archivo que contiene una secuencia de comandos que son ejecutados por el programa de bash línea por línea. Te permite realizar una serie de acciones, tales como navegar a un directorio específico, crear una carpeta, y ejecutar un proceso usando la línea de comando.

Al guardar estos comandos en un script, puedes repetir la misma secuencia de pasos múltiples veces y ejecutarlos al correr el script.

Ventajas de la programación de Bash

La programación de Bash es una herramienta poderosa y versátil para automatizar tareas de administración de sistema, gestionar recursos del sistema, y realizar otras tareas rutinarias en sistemas Unix/Linux. Algunas ventajas de la programación de shell son:

• Automatización: Los scripts de Shell te permiten automatizar tareas y procesos repetitivos, ahorrando tiempo y reduciendo el riesgo de errores que pueden ocurrir con ejecución manual.
• Portabilidad: Los scripts de Shell pueden ser ejecutados en varias plataformas y sistemas operativos, incluyendo Unix, Linux y macOS, e inclusive Windows a través del uso de emuladores o máquinas virtuales.
• Flexibilidad: Los scripts de Shell son altamente personalizables y pueden ser fácilmente modificados para adaptarse a requerimientos específicos. También pueden ser combinados con otros lenguajes de programación o utilidades para crear scripts más poderosos.
• Accesibilidad: Los scripts de Shell son fáciles de escribir y no requieren ninguna herramienta o software especial. Pueden ser editados usando cualquier editor de texto, y la mayoría de los sistemas operativos tienen un intérprete de shell incluido.
• Integración: Los scripts de Shell pueden ser integrados con otras herramientas y aplicaciones, tales como bases de datos, servidores web, y servicios de la nube, así permitiendo tareas de automatización más compleja y gestión de sistema.
• Depuración: Los scripts de Shell son fáciles de depurar, y la mayoría de los shells tienen un depurador incorporado y herramientas de reporte de errores que pueden ayudar en identificar y arreglar problemas rápidamente.

Vista general de la terminal de Bash y la interfaz de línea de comandos

Los términos "shell" y "bash" son usados indistintamente. Pero hay una sutil diferencia entre los dos.

El término "shell" se refiere a un programa que provee una interfaz de línea de comandos para interactuar con un sistema operativo. Bash (Bourne-Again SHell) es una de las terminales de Unix/Linux más comúnmente utilizados en muchas distribuciones de Linux.

Una terminal o interfaz de línea de comandos luce de esta forma:

En la salida de arriba, zaira@Zaira es el prompt de la shell. Cuando una terminal es usado interactivamente, muestra un $ cuando está esperando un comando del usuario.

Si la terminal se está ejecutando como root (un usuario con permisos administrativos), el prompt se cambia a #. El prompt del shell del superusuario luce así:

[root@host ~]#

Aunque Bash es un tipo de shell, hay otras shells disponibles también, tales como la shell Korn (ksh), la shell C (csh), y la shell Z (zsh). Cada shell tiene su propia sintaxis y conjunto de características, pero todos comparten el propósito en común de proporcionar una interfaz de línea de comandos para interactuar con el sistema operativo.

Puedes determinar tu tipo de shell usando el comando ps:

ps

Esta es la salida para mí:

En resumen, mientras que "shell" es un término amplio que se refiere a cualquier programa que proporciona una interfaz de línea de comandos, "Bash" es un tipo específico de shell que es ampliamente usando en sistemas Unix/Linux.

Nota: en este tutorial, estaremos usando la shell "bash".

Cómo empezar con la programación de Bash

Cómo ejecutar comandos de Bash desde la Línea de Comandos

Como mencioné anterioremente, el prompt de la shell luce así:

[username@host ~]$

Puedes ingresar cualquier comando después del signo $ y ver la salida de la shell.

Generalmente, los comandos siguen esta sintaxis:

comando [OPCIONES] argumentos

Discutamos unos pares de comandos de bash básicos y veamos sus salidas. Asegúrate de seguirme :)

• date: Muesta la fecha actual.

zaira@Zaira:~/shell-tutorial$ date
Tue Mar 14 13:08:57 PKT 2023

• pwd: Muestra la carpeta de trabajo presente.

zaira@Zaira:~/shell-tutorial$ pwd
/home/zaira/shell-tutorial

• ls: Lista los contenidos de la carpeta actual.

zaira@Zaira:~/shell-tutorial$ ls
check_plaindrome.sh  count_odd.sh  env  log  temp

• echo: Imprime una cadena de texto, o el valor de una variable a la terminal.

zaira@Zaira:~/shell-tutorial$ echo "Hello bash"
Hello bash

Siempre puedes referirte al manual de los comandos con el comando man.

Por ejemplo, el manual para ls se ve así:

Cómo crear y ejecutar scripts de Bash

Convenciones de nombramiento de Script

Por convención de nomenclatura, los scripts de bash terminan con .sh. Sin embargo, los scripts de bash pueden ejecutarse perfectamente sin la extensión sh.

Agregando el Shebang

Los scripts de Bash comienzan con un shebang. Shebang es una combinación de bash # y bang ! seguido del path de la shell de bash. Esta es la primer línea del script. Shebang le dice a la shell que lo ejecute por medio de la shell de bash. Shebang es simplemente un path absoluto al intérprete de bash.

Abajo hay un ejemplo de la sentencia shebang.

#!/bin/bash

Puedes encontrar tu path de la shell de bash (el cual podría variar del de arriba) usando el comando:

which bash

Creando nuestro primer script de bash

Nuestro primer script le dice al usuario que ingrese una ruta. Como respuesta, su contenido será listado.

Crea un archivo llamado run_all.sh usando el comando vi. Puedes usar cualquier editor de tu preferencia.

vi run_all.sh

Agrega los siguientes comandos en tu archivo y guárdalo:

#!/bin/bash
echo "Hoy es " `date`

echo -e "\ningresa la ruta al directorio"
read the_path

echo -e "\n tu ruta tiene los siguientes archivos y carpetas: "
ls $the_path

Miremos aún más de cerca al script línea por línea. Estoy mostrando el mismo script de nuevo, pero esta vez con números de línea.

  1 #!/bin/bash
  2 echo "Hoy es " `date`
  3
  4 echo -e "\nIngresa la ruta al directorio"
  5 read the_path
  6
  7 echo -e "\n tu ruta tiene los siguientes archivos y carpetas: "
  8 ls $the_path

• Línea #1: El shebang (#!/bin/bash) apunta hacia la ruta de la shell de bash.
• Línea #2: El comando echo muestra la fecha actual y el tiempo en la shell. Nota que el date está con comillas invertidas.
• Línea #4: Queremos que el usuario ingrese una ruta válida.
• Línea #5: El comando read lee la entrada y lo almacena en la variable the_path.
• Línea #8: El comando ls toma la variable con la ruta almacenada y muestra los archivos y las carpetas actuales.

Ejecutando el script del bash

Para hacer que el script sea ejecutable, asigna permisos de ejecución para tu usuario usando este comando:

chmod u+x run_all.sh

Aquí,

• chmod modifica la posesión de un archivo para el usuario actual :u.
• +x agrega los privilegios de ejecución al usuario actual. Esto significa que el usuario quien es el propietario ahora puede ejecutar el script.
• run_all.sh es el archivo que deseamos ejecutar.

Ahora puedes ejecutar el script usando cualquiera de los métodos mencionados:

• sh run_all.sh
• bash run_all.sh
• ./run_all.sh

Veámoslo ejecutando una acción 🚀

Lo esencial sobre Programación de Bash

Comentarios en programación de bash

Los comentarios comienzan con un # en programacioń de bash. Esto significa que cualquier línea que comience con un # es un comentario y será ignorado por el intérprete.

Los comentarios son muy útiles al documentar el código, y es una buena práctica agregarlos para ayudar a los demás entender el código.

Estos son ejemplos de comentarios:

# Este es un comentario de ejemplo
# Estas dos líneas serán ignoradas por el intérprete

Variables y tipos de datos en Bash

Las variables te permiten almacenar datos. Puedes usar variables para leer, acceder, y manipular datos en todo tu script.

No hay tipos de datos en Bash. En Bash, una variable es capaz de almacenar valores numéricos, caracteres individuales, o cadenas de caracteres.

En Bash, puedes usar y establecer los valores de variable de las siguientes formas:

1. Asignar el valor directamente:

pais=Pakistan

2.  Asignar el valor basado en la salida obtenida de un programa o de un comando, usando la substitución de comando. Ten en cuenta que $ se requiere para acceder a un valor de una variable existente.

mismo_pais=$pais

Para acceder al valor de la variable, adjunta $ al nombre de la variable.

zaira@Zaira:~$ pais=Pakistan
zaira@Zaira:~$ echo $pais
Pakistan
zaira@Zaira:~$ nuevo_pais=$pais
zaira@Zaira:~$ echo $nuevo_pais
Pakistan

Convenciones de nomenclatura de Variable

En programación de Bash, las convenciones de nomenclatura de variable son los siguientes:

1. Los nombres de variable deberían comenzar con una letra o un guión bajo (_).
2. Los nombres de variable pueden contener letras, números, y guiones bajos (_).
3. Los nombres de variable se distinguen entre mayúsculas y minúsculas.
4. Los nombres de variable no deberían contener espacios o caracteres especiales.
5. Usa nombres descriptivos que reflejen el propósito de la variable.
6. Evitar usar palabras claves reservadas, tales como if, then, else, fi, y así sucesivamente como nombres de variable.

Aquí hay algunos ejemplos de nombres de variable válidos en Bash:

nombre
cuenta
_var
miVar
MI_VAR

Y aquí hay algunos ejemplos de nombres de variable inválidos:

2ndvar (el nombre de variable comienza con un número)
mi var (el nombre de variable contiene un espacio)
mi-var (el nombre de variable contiene un guión)

Siguiendo estas convenciones de nomenclatura ayuda en hacer los scripts de Bash más legibles y más facil de mantener.

Entradas y salidas en scripts de Bash

Recopilación de entradas

En esta sección, discutiremos algunos de los métodos para proveer entrada a nuestros scripts.

1. Leer la entrada del usuario y almacenarlo en una variable

Podemos leer la entrada de usuario usando el comando read.

#!/bin/bash
echo "Hoy es " `date`

echo -e "\ningresa la ruta al directorio"
read la_ruta

echo -e "\ntu ruta tiene los siguientes archivos y carpetas: "
ls $la_ruta

2.  Leer de un archivo

Este código lee cada línea de un archivo llamado input.txt y lo imprime en la shell. Estudiaremos bucles de while más adelante en este artículo.

while read linea
do
  echo $linea
done < input.txt

3.  Argumentos de Línea de Comando

En un script bash o una función, $1 denota el argumento inicial provisto, $2 denota el segundo argumento provisto, y así sucesivamente.

Este script toma un nombre como un argumento de línea de comando e imprime un saludo personalizado.

echo "Hello, $1!"

Hemos suplido Zaira como nuestro argumento al script.

#!/bin/bash
echo "Hello, $1!"

Salida:

Mostrando la salida

Aquí discutiremos algunos de los métodos para recibir salida de los scripts.

1. Imprimir en la terminal:

echo "Hola, Mundo!"

Esto imprime el texto "Hola, Mundo!" en la terminal.

2.  Escribir a un archivo:

echo "Esto es un texto." > output.txt

Esto escribe el texto "Esto es un texto." a un archivo llamado output.txt. Ten en cuenta que el operador > sobrescribe un archivo si éste ya tiene algún contenido.

3.  Adjuntar a un archivo:

echo "Mas texto." >> output.txt

Esto adjunta el texto "Mas texto." al final del archivo output.txt.

4.  Redireccionando la salida:

ls > files.txt

Esto lista los archivos en el directorio actual y escribe la salida a un archivo llamado files.txt. Puedes redirigir la salida de cualquier comando a un archivo de este forma.

Comandos básicos de Bash (echo, read, etc.)

Aquí hay una lista de algunos de los comandos de bash más comúnmente usados:

1. cd: Cambia el directorio a un lugar distinto.
2. ls: Lista los contenidos del directorio actual.
3. mkdir: Crea un nuevo directorio.
4. touch: Crea un nuevo archivo.
5. rm: Elimina un archivo o un directorio.
6. cp: Copia un archivo o un directorio.
7. mv: Mueve o renombra un archivo o un directorio.
8. echo: Imprime texto a la terminal.
9. cat: Concatena e imprime los contenidos de un archivo.
10. grep: Busca un patrón en un archivo.
11. chmod: Cambia los permisos de un archivo o de un directorio.
12. sudo: Ejecutar un comando con privilegios administrativos.
13. df: Mostrar la cantidad de espacio de disco disponible.
14. history: Mostrar una lista de comandos ejecutados previamente.
15. ps: Mostrar información sobre procesos en ejecución.

Declaraciones condicionales (if/else)

Expresiones que producen un resultado booleano, sea verdadero o falso, son llamados condiciones. Hay varias formas de evaluar condiciones, incluyendo if, if-else, if-elif-else, y condicionales anidadas.

Sintaxis:

if [[ condicion ]];
then
	declaracion
elif [[ condicion ]]; then
	declaracion 
else
	haz esto por defecto
fi

Podemos usar operadores lógicos tales como AND -a y OR -o para hacer comparaciones que tienen más significado.

if [ $a -gt 60 -a $b -lt 100 ]

Veamos un ejemplo de un script de Bash que usa declaraciones de if, if-else, y if-elif-else para determinar si el número introducido por el usuario es positivo, negativo, o cero:

#!/bin/bash

echo "Por favor ingresa un numero: "
read num

if [ $num -gt 0 ]; then
  echo "$num es positivo"
elif [ $num -lt 0 ]; then
  echo "$num es negativo"
else
  echo "$num es cero"
fi

El script primero imprime un mensaje al usuario para que ingrese un número. Luego, usa una declaración if para verificar si el número es mayor que 0. Si lo es, el script muestra que el número es positivo. Si el número no es mayor que 0, el script se mueve a la siguiente declaración, el cual es una declaración if-elif. Aquí, el script verifica si el número es menor que 0. Si lo es, el script muestra que el número es negativo. Finalmente, si el número ni es mayor que 0 ni menor que 0, el script usa una declaración else para mostrar que el número es cero.

Míralo en acción 🚀

Bucles y ramificación en Bash

Bucle While

Los bucles while verifican una condición y hacen un bucle hasta que la condición sea true. Necesitamos proveer un contador que vaya incrementándose para controlar la ejecución del bucle.

En el ejemplo de abajo, (( i += 1 )) está la declaración contador que incrementa el valor de i. El bucle lo ejecutará exactamente 10 veces.

#!/bin/bash
i=1
while [[ $i -le 10 ]] ; do
   echo "$i"
  (( i += 1 ))
done

Bucle for

El bucle for, así como el bucle while, te permite ejecutar declaraciones en un número específico de veces. Cada bucle difiere en su sintaxis y uso.

En el ejemplo de abajo, el bucle iterará 5 veces.

#!/bin/bash

for i in {1..5}
do
    echo $i
done

Declaraciones Case

En Bash, las declaraciones case son usados para comparar un valor dado con una lista de patrones y ejecutar un bloque de código basado en el primer patrón que coincida. La sintaxis para una declaración case en Bash es como lo que sigue:

case expression in
    pattern1)
        # código a ejecutar si la expresión coincide con pattern1
        ;;
    pattern2)
        # código a ejecutar si la expresión coincide con pattern2
        ;;
    pattern3)
        # código a ejecutar si la expresión coincide con pattern3
        ;;
    *)
        # código a ejecutar si ninguno de los patrones de arriba coincide con la expresión
        ;;
esac

Aquí, "expression" es el valor que queremos comparar, y "pattern1", "pattern2", "pattern3", y así sucesivamente son los patrones con los que queremos comparar.

El doble punto y coma ";;" separa cada bloque de código para ejecutar cada patrón. El asterisco "*" representa el caso por defecto, el cual se ejecuta si ninguno de los patrones especificados coinciden con la expresión.

Veamos un ejemplo:

fruta="manzana"

case $fruta in
    "manzana")
        echo "Este es una fruta roja."
        ;;
    "banana")
        echo "Este es una fruta amarilla."
        ;;
    "orange")
        echo "Este es una fruta naranja."
        ;;
    *)
        echo "Fruta desconocida."
        ;;
esac

En este ejemplo, ya que el valor de "fruta" es "manzana", el primer patrón coincide, y el bloque de código que imprime "Este es una fruta roja." Se ejecuta. Si el valor de "fruta" fuere "banana", el segundo patrón coincidiría y el bloque de código que imprime "Este es una fruta amarilla." Se ejecutaría, y así sucesivamente. Si el valor de "fruta" no coincide con ninguno de los patrones especificados, el caso por defecto se ejecuta, el cual imprime "Fruta desconocida."

Cómo programar Scripts usando cron

Cron es una utilidad poderosa para programar trabajos que está disponible en sistemas operativos tipo Unix. Al configurar cron, puedes configurar trabajos automatizados que se ejecuten diariamente, semanalmente, mensualmente, o en una base de tiempo específica. Las capacidades de automatización provista por cron juegan un papel crucial en la administración del sistema Linux.

Abajo está la sintaxis para programar crons:

# Ejemplo de un trabajo Cron 
* * * * * sh /path/to/script.sh

Aquí, los * representan minuto(s) hora(s) día(s) mes(es) semana(s), respectivamente.

Abajo hay algunos ejemplos de programación de trabajos cron.

Usando crontab

La utilidad crontab es usado para agregar y editar los trabajos cron.

crontab -l lista los scripts ya programados para un usuario particular.

Puedes agregar y editar el cron con crontab -e.

Puedes leer más sobre los trabajos cron en mi otro artículo aquí.

Cómo depurar y solucionar problemas de scripts de Bash

Depurar y solucionar problemas son habilidades esenciales para cualquier programador de Bash. Mientras que los scripts de Bash pueden ser increíblemente poderosos, también pueden ser propicios a tener errores y con comportamientos inesperados. En esta sección, discutiremos algunos consejos y técnicas para depurar y solucionar problemas en scripts de Bash.

Establecer la opción set -x

Una de las técnicas más útiles para depurar scripts de Bash es establecer la opción set -x al principio del script. Esta opción permite el modo en depuración, el cual hace que Bash imprima cada comando que ejecuta a la terminal, precedido por un signo +, Esto puede ser increíblemente útil al identificar dónde ocurren los errores en tu script.

#!/bin/bash

set -x

# Tu script va aquí

Verifica el código de salida

Cuando Bash encuentra un error, pone un código de salida que indica la naturaleza del error. Puedes verificar el código de salida del comando más reciente usando la variable $?. Un valor de 0 indica éxito, mientras que cualquier otro valor indica un error.

#!/bin/bash

# Tu script va aquí

if [ $? -ne 0 ]; then
    echo "Hubo un error."
fi

Usa declaraciones echo

Otra técnica útil para depurar scripts de Bash es insertar declaraciones echo a lo largo de tú código. Esto puede ayudarte en identificar cuando ocurren los errores y qué valores están siendo pasados a las variables.

#!/bin/bash

# Tu script va aquí

echo "El valor de la variable x es: $x"

# Más código va aquí

Usa la opción set -e

Si quieres que tu script salga inmediatamente cuando cualquier comando en el script falle, puedes usar la opción set -e. Esta opción hará que Bash salga con un error si cualquier comando en el script falle, haciendo más fácil de identificar y arreglar errores en tu script.

#!/bin/bash

set -e

# Tu script va aquí

Resolviendo problemas de crons verificando los logs

Podemos solucionar problemas de crons usando los archivos de log. Los logs son mantenidos para todos los trabajos programados. Puedes verificar en los logs si un trabajo específico se ejecutó como se pretendía o no.

Para Ubuntu/Debian, puedes encontrar los logs de cron en:

/var/log/syslog

La ubicación varía para otras distribuciones.

Un archivo log de un trabajo de cron luce así:

2022-03-11 00:00:01 Tarea iniciada
2022-03-11 00:00:02 Ejecutando script /ruta/a/script.sh
2022-03-11 00:00:03 El script se completó exitosamente
2022-03-11 00:05:01 Tarea iniciada
2022-03-11 00:05:02 Ejecutando script /ruta/a/script.sh
2022-03-11 00:05:03 Error: no se pudo conectar a la base de datos
2022-03-11 00:05:03 El script salió con código de error 1
2022-03-11 00:10:01 Tarea iniciada
2022-03-11 00:10:02 Ejecutando script /ruta/a/script.sh
2022-03-11 00:10:03 El script se completó exitosamente 

Conclusión

En este artículo, comenzamos con cómo acceder a la shell y luego ejecutamos algunos comandos básicos de Bash. También estudiamos lo que es una terminal de Bash. Brevemente, miramos la ramificación de código usando bucles y condicionales. Finalmente, discutimos sobre automatizar los scripts usando cron seguido de algunas técnicas de solución de problemas.

Recursos para aprender más sobre programación de Bash

Si quieres indagar más profundamente en el mundo de la programación de Bash, te sugeriría que mires a este curso de 6 horas en Linux en freeCodeCamp (en inglés).

¿Qué es lo que más te gusta de lo que aprendiste de este tutorial? Puedes también contactarme en cualquiera de estas plataformas. 📧�

Nos vemos en el próximo tutorial, feliz codificación 😁

Créditos de la imagen de portadas: Imagen por Freepik

Uno de los primeros comandos que aprendí en Linux fue el comando touch que crea un archivo usando la línea de comando.

Si alguna vez tratas de crear, por ejemplo, un archivo de texto, todo lo que tienes que hacer es escribir touch filename.txt, presionar Enter, y el archivo es creado para ti en la carpeta donde estás. Luego puedes escribir lo que quieras dentro usando el editor de archivos de tu gusto.

Sin embargo, cuando se trata de crear scripts, las cosas se pueden poner un poco más complicadas. ¿Por qué es eso?

Déjame intentar mostrarte esto con un ejemplo. Supón que quieres crear un script usando 'touch'. Escribe touch example.sh, presiona Enter, y ahí lo tienes. Una vez más, puedes escribirlo usando un editor de archivos.

Con todo listo, todo lo que nos resta hacer es probarlo. Escribe ./sample.sh y presiona Enter para ver tu script en acción y... pero, ¿qué me está diciendo este mensaje?

¿Por qué necesitamos permisos?

¡Yo soy el administrador! ¿Cómo es posible que no tengo permiso para ejecutar un script que yo mismo escribí segundos atrás?

En realidad hay una razón para eso – y, para ser honesto, la mayoría de usuarios deberían de ser agradecidos por ello, ya que no ser capaz de ejecutar scripts sin saber qué se está haciendo frecuentemente te previene de poner tu sistema en riesgo.

Vamos a conversar rápidamente sobre los permisos primero. Luego pasaremos a descubrir cómo cambiarlos.

Para obtener más información sobre tu archivo, usaremos el comando que lista los archivos en una carpeta: ls.

Después de escribir ls y presionar Enter, esto es lo que obtenemos de la línea de comando:

Lo que hace es listar todos los archivos visibles de la carpeta en el que estás en este momento. Al agregarle la bandera -l, te provee con más información sobre los archivos de la carpeta. Este es el resultado cuando escribimos ls -l y presionamos Enter:

Vemos el mismo archivo(s), pero con bastante información. Para empezar, tenemos una secuencia de diez guiones y letras que podrían parecer sin sentido a la primera. Esto es en realidad es el mapeo de permisos que tu archivo tiene.

El primer carácter puede ser un guion (- para un archivo común), una d (para una carpeta/directorio), o una l (para un enlace suave). Para ser más sencillos, me enfocaré en los archivos simples, aunque los permisos son válidos para todos estos tipos de archivos/carpetas.

Después del primer carácter, los otros 9 pueden ser divididos en grupos de tres. El primer trío muestran los permisos para el usuario actual. El próximo muestra los permisos para este grupo. Los últimos tres son los permisos para todos los usuarios que no encajan en esta categoría.

Para nuestra explicación, enfoquémonos en los primeros tres permisos, ya que no vamos a cambiar grupos ni nada parecido.

El primer trío dice rw-.

Es tiempo de entender qué son estos. Hay tres cosas que puedes hacer normalmente con un archivo: leerlo, escribir en él, y ejecutarlo. Eso es, básicamente, lo que significa esas tres letras.

La primera r se refiere a permisos de lectura. Luego tenemos w para permisos de escritura. Finalmente, un guion, lo que significa que cualquier cosa que debería estar ahí no está. Lo que debería de haber allí es una x, lo que significa ejecutable.

Así que, hablando del usuario actual (yo), los permisos que tengo para este archivo son los permisos de lectura y de escritura. No puedo, sin embargo, ejecutar el archivo sample.sh. Por eso, cuando tratamos de ejecutar el archivo, tengo ese mensaje 'permiso denegado'.

Entonces, ¿cómo puedo ejecutar este archivo? Ahí es donde el comando chmod entra en acción.

¿Qué hace chmod?

Bueno, he estado mencionando 'permisos' desde el inicio del artículo. Ampliemos esta explicación un poco para denotar qué son 'permisos' para acceder a un archivo de un cierto modo. Esto significa que r denota el permiso de acceder al archivo en modo lectura, w denota el permiso de acceder al archivo en modo escritura, y x denota el permiso de acceder al archivo en modo ejecución.

¿Por qué te estoy diciendo esto? Por el comando del que trata este artículo. chmod significa 'cambiar el modo'. En otras palabras, cuando uses este comando, estás cambiando el modo del archivo a cualquier modo que quieres usar.

Cómo usar los Operadores con cmod

Es necesario usar un operador con el comando chmod. Sirve para especificar el tipo de cambio que quieres hacer en los permisos.

Por ejemplo, + es el operador que usas para agregar un permiso a los que el archivo ya tiene. - remueve un permiso de la lista. Hay también el operador =, lo cual reinicia los permisos, así puedes definirlos nuevamente.

En nuestro caso, al escribir chmod -w sample.sh, lo que le estoy pidiendo al comando que haga es remover el permiso de escritura. Así que lo que tendría que hacer para agregar el permiso de ejecución es escribir chmod +x sample.sh.

Si ahora intento ejecutar el archivo, cualquier cosa que ponga en el script ahora va a ser ejecutado.

Usando ls -l, esto es lo que tendría ahora.

¿Quién obtiene el permiso?

Algo más que vale la pena señalar es quién es el que obtiene este permiso. Verás que el 'x' es dado a todos los usuarios, al dueño del archivo, grupo y otros. Si esto no es lo que quieres, tal vez sería bueno quitar el permiso de ejecución nuevamente con chmod -x sample.sh.

Para activar el permiso solamente para el dueño del archivo (yo, en este caso), deberíamos agregar una 'u' antes de '+x', así:

chmod u+x sample.sh

Escribe ls -l, esto es lo que tienes:

Si querías dar el permiso tanto para el dueño como su grupo, entonces el comando debería ser chmod ug+x sample.sh.

¡Genial! Pienso que esto cubre lo que querría mostrarte. Hay otras cosas que te interesarían, como usar chmod con valores octales o binarios para representar los permisos. Pero estos son modos que usamos para tener los mismos resultados y creo que con las letras es una forma más sencilla de lograr estos resultados.

En caso de que quieras más información sobre el comando, una cosa que puedes hacer es escribir chmod --help, el cual te dará un resumen de lo que el comando puede hacer. Una descripción aún más detallada se puede lograr escribiendo man chmod.

Espero que este artículo te haya sido de utilidad. Para más artículos sobre comandos de Linux, visita freecodecamp.org/espanol/news y freecodecamp.org/news.

¡Feliz codificación! 😃

Secure Shell (SSH) es un protocolo de red ampliamente utilizado que proporciona una forma segura de acceder a servidores remotos y computadoras.

En Linux, SSH es una herramienta esencial para la administración remota y transferencia de archivos. En este artículo, repasaremos el significado de SSH en Linux, su historia, características, configuración y casos de uso.

¿Qué es SSH?

SSH es un protocolo de red criptográfico que permite una comunicación segura entre dispositivos en red. Fue desarrollado como reemplazo de Telnet, un protocolo que enviaba todos los datos, incluyendo contraseñas, en texto sin formato, lo que lo hacía susceptible a escuchas e interceptaciones.

SSH proporciona mecanismos de cifrado y autenticación para proteger la confidencialidad e integridad de las comunicaciones en la red.

Historia breve de SSH

La primera versión de SSH, SSH-1, fue desarrollada por Tatu Ylönen en 1995 como respuesta a la inseguridad de Telnet y FTP.

En 1996, SSH Communications Security lanzó una versión comercial de SSH-1, que se volvió ampliamente utilizada en la industria.

Pero  SSH-1  tenía algunas vulnerabilidades de seguridad, y en 1998, Ylönen desarrolló SSH-2, que abordó estos problemas y se convirtió en la versión más utilizada de SSH.

Como funciona SSH

SSH utiliza una arquitectura cliente-servidor, donde el cliente inicia una conexión con el servidor y solicita un canal de comunicación seguro. El servidor responde generando un par de claves criptográficas, una pública y otra privada.

La clave pública se envía al cliente, mientras que la clave privada se guarda de forma segura en el servidor. Luego, el cliente cifra una clave de sesión aleatoria utilizando la clave pública del servidor y la envía de regreso al servidor. El servidor descifra la clave de sesión utilizando su clave privada y envía un acuse de recibo al cliente. A partir de este momento, todos los datos transmitidos entre el cliente y el servidor se cifran utilizando la clave de sesión.

Características SSH

• Encriptación: SSH utiliza algoritmos de encriptación fuertes, como AES, para proteger la confidencialidad e integridad de los datos transmitidos a través de la red.
• Transferencia segura de archivos: Proporciona capacidades de transferencia segura de archivos (SFTP), que permiten a los usuarios transferir archivos entre servidores remotos de forma segura.
• Inicio de sesión remoto: SSH proporciona una forma segura de iniciar sesión en servidores y computadoras remotos, sin exponer las credenciales de inicio de sesión a los atacantes.
• Reenvío de puertos: proporciona una forma segura de iniciar sesión en servidores y computadoras remotas, que permiten a los usuarios acceder a servicios restringidos en servidores remotos a través de un canal de comunicación seguro.
• Reenvío de X11: SSH proporciona capacidades de reenvío X11, que permiten a los usuarios ejecutar aplicaciones gráficas de forma remota, sin tener que instalarlas localmente.
• Reenvío de agente: También proporciona capacidades de reenvío de agentes, que permiten a los usuarios usar claves SSH para autenticación en servidores remotos, sin tener que ingresar su contraseña cada vez.

Configuración SSH

La configuración SSH implica varias configuraciones y opciones que se pueden personalizar para optimizar la conexión SSH y mejorar la seguridad. A continuación se muestran algunas tareas comunes de configuración de SSH:

• Generación de claves SSH: Antes de usar SSH, los usuarios deben generar un par de claves criptográficas, una pública y una privada. La clave pública se comparte con el servidor, mientras que la clave privada se guarda de forma segura en el ordenador del usuario.
• Edición de archivos de configuración: Los usuarios pueden crear y editar archivos de configuración SSH para personalizar su configuración SSH, como especificar el algoritmo de cifrado preferido o configurar el reenvío de puertos. Los archivos de configuración SSH suelen estar ubicados en el directorio /etc/ssh/.
• Métodos de autenticación: SSH admite varios métodos de autenticación, como la autenticación mediante contraseña, la autenticación mediante clave pública y la autenticación multifactorial. Los usuarios pueden elegir el método de autenticación más adecuado en función de sus necesidades de seguridad.
• Configuración segura de SSH: Para garantizar la máxima seguridad, los usuarios deben seguir las mejores prácticas para la configuración segura de SSH, como desactivar el inicio de sesión como root, exigir contraseñas seguras y limitar el número de intentos fallidos de inicio de sesión. Los usuarios también pueden utilizar herramientas como Fail2Ban para evitar ataques de fuerza bruta en SSH.
• Habilitar el reenvío X11: SSH proporciona capacidades de reenvío X11, que permiten a los usuarios ejecutar aplicaciones gráficas de forma remota sin tener que instalarlas localmente. Para habilitar el reenvío X11, los usuarios pueden añadir la opción -X o -Y al conectarse al servidor remoto.
• Reenvío de puertos: SSH permite a los usuarios configurar el reenvío de puertos, lo que puede ser útil para acceder a servicios restringidos en servidores remotos a través de un canal de comunicación seguro. Los usuarios pueden configurar el reenvío de puertos local o remoto según sus necesidades.
• Compresión: SSH admite la compresión de datos, lo que puede mejorar el rendimiento de la conexión SSH, especialmente al transferir archivos grandes o ejecutar aplicaciones que requieren muchos recursos. Los usuarios pueden habilitar la compresión añadiendo la opción -C al conectarse al servidor remoto.

SSH Examples and Use Cases

• La administración remota de servidores: SSH se utiliza habitualmente para la administración remota de servidores, permitiendo a los usuarios ejecutar comandos y gestionar servidores desde una ubicación remota.
• Transferencia segura de archivos: proporciona una forma segura de transferir archivos entre servidores remotos, sin exponer los archivos o las credenciales de inicio de sesión a atacantes.
• Ejecución de aplicaciones gráficas de forma remota: permite a los usuarios ejecutar aplicaciones gráficas de forma remota, sin tener que instalarlas localmente, lo que puede ser útil para aplicaciones que requieren muchos recursos o cuando se utiliza un dispositivo de baja potencia.
• Reenvío de puertos para acceder a servicios restringidos: permite a los usuarios acceder a servicios restringidos en servidores remotos a través de un canal de comunicación seguro, mediante el establecimiento de un reenvío de puertos.
• Túneles para comunicación segura: SSH permite a los usuarios establecer túneles cifrados para la comunicación segura entre dos dispositivos en red, lo que puede ser útil para acceder a recursos en una red privada.

Conclusión

Para concluir este artículo, aquí hay un resumen de lo que cubrimos y lo que debe saber sobre SSH:

• SSH es un protocolo seguro para la comunicación remota en Linux.
• SSH utiliza cifrado para proteger los datos y mecanismos de autenticación para verificar a los usuarios.
• SSH es una forma confiable y eficiente de comunicarse de forma segura a través de Internet, y es una herramienta vital para la administración y el desarrollo del sistema Linux.
• SSH proporciona capacidades de inicio de sesión remoto, transferencia segura de archivos, reenvío de puertos, reenvío X11 y reenvío de agentes.
• Para usar SSH, los usuarios deben generar un par de claves criptográficas, una pública y una privada.
• Los archivos de configuración SSH se pueden personalizar para optimizar la conexión SSH y mejorar la seguridad.
• SSH admite varios métodos de autenticación, como la autenticación mediante contraseña, la autenticación mediante clave pública y la autenticación multifactorial.
• Para garantizar la máxima seguridad, los usuarios deben seguir las mejores prácticas para la configuración segura de SSH, como desactivar el inicio de sesión como root, exigir contraseñas seguras y limitar el número de intentos fallidos de inicio de sesión.
• SSH se puede utilizar para la administración remota del servidor, transferencia segura de archivos, ejecución de aplicaciones gráficas de forma remota, reenvío de puertos y túneles para comunicación segura.
• SSH es un protocolo ampliamente utilizado y compatible, con muchos clientes y servidores SSH disponibles para diferentes plataformas.

Conectémonos en Twitter y LinkedIn. También puedes suscribirte a mi canal de YouTube.

¡Feliz programación!

Cuando se programa, es posible que necesites tomar decisiones basadas en ciertas condiciones. Las condiciones son expresiones que se evalúan como una expresión booleana (true o false).

Las sentencias que ayudan a ejecutar diferentes ramas de código basándose en ciertas condiciones se conocen como sentencias condicionales.

if...else es una de las sentencias condicionales utilizadas más comúnmente. Al igual que otros lenguajes de programación, la programación de Bash también soporta sentencias if...else. Y lo estudiaremos en detalle en esta publicación.

Sintaxis de las declaraciones if

Puedes utilizar las declaraciones if de varias formas.  La estructura genérica de las declaraciones  if es la siguiente:

• Usando solo una declaración if:   if...then...fi
• Usando una declaración if con una declaración else:   if...then...else...fi
• Usando varias declaraciones else Cuando estás utilizando una sola declaración if: if..elif..else..fi

Cómo utilizar la declaración if

Cuando estás utilizando una sola declaración if , la sintaxis es la siguiente:

if [ condition ]
then
	statement
fi

Ten en cuenta que los espacios forman parte de la sintaxis y no deben ser eliminados

Veamos un ejemplo donde estamos comparando dos números para ver si el primer número es el más pequeño.

#! /bin/sh

a=5
b=30

if [ $a -lt $b ]
then
        echo "a is less than b"
fi

Si ejecutas el fragmento anterior, la condición  if [ $a -lt $b ] se evalúa como True, y se ejecuta la declaración dentro de la declaración if.

Resultado:

a is less than b

¿Cómo utilizar la declaración if .. else?

Cuando estás utilizando una declaración if y quieres añadir otra condición, la sintaxis es la siguiente:

if [ condition ]
then
	statement
else
	do this by default
fi

Veamos un ejemplo en el que queramos encontrar si el primer número es mayor o menor que el segundo. Aquí,  if [ $a -lt $b ] se evalúa como false, lo que provoca que se ejecute la parte else del código.

#! /bin/sh

a=99
b=45

if [ $a -lt $b ]
then
        echo "a is less than b"
else
        echo "a is greater than b"
fi

Resultado:

a is greater than b

¿Cómo utilizar las declaraciones if..elif..else?

Digamos que quieres añadir condiciones y comparaciones adicionales para hacer que el código sea dinámico. En este caso, la sintaxis se vería así:

if [ condition ]
then
	statement
elif [ condition ] 
then
	statement 
else
	do this by default
fi

Para crear comparaciones significativas, podemos usar los operadores lógicos AND -a y OR -o.

En este ejemplo, vamos a determinar el tipo de triángulo utilizando las siguientes condiciones:

• Escaleno:  Un triángulo en el que cada lado tiene una longitud diferente.
• Isósceles: Un triángulo en el que 2 de sus lados tienen la misma longitud.
• Equilátero: Un triángulo en el que todos los lados tienen la misma longitud.

read a
read b
read c

if [ $a == $b -a $b == $c -a $a == $c ]
then
echo ESCALENO

elif [ $a == $b -o $b == $c -o $a == $c ]
then
echo ISOSCELES
else
echo EQUILATERO

fi

En el ejemplo anterior, el script le pediría al usuario que ingrese los tres lados del triángulo. Luego, compararía los lados y decidiría el tipo de triángulo.

3
4
5
SCALENE

Conclusión

Puedes fácilmente dividir tu código en ramas basándose en condiciones como if..else y hacer el código más dinámico. En este tutorial, aprendiste la sintaxis de if...else junto con algunos ejemplos.

Espero que hayas encontrado este tutorial útil.

Comenta que aprendiste de este tutorial. ¡Házmelo saber en  Twitter!

El nombre tares la abreviatura de archivo de cinta . Las "cintas" en cuestión serían todas esas unidades de almacenamiento magnético que fueron populares en la década de 1950.

Esto sugiere que la herramienta tar podría ser un poco vieja y haber pasado su mejor momento. Pero la verdad es que, a lo largo de los años y a través de todos los cambios sísmicos en el mundo de TI, tar no ha perdido nada de su poder y valor.

En este artículo, basado en el contenido de mi libro Linux en acción (en inglés), te mostraré los conceptos básicos de la creación, compresión y restauración de archivos tar. Empecemos desde el principio.

Creando archivos

Este ejemplo cogerá todos los archivos y directorios dentro y debajo del directorio de trabajo actual y creará un archivo de almacenamiento que he llamado nombredearchivo.tar.

Aquí uso tres argumentos después del comando tar:

• la cle dice a tar que cree un nuevo archivo,
• vestablece la salida por pantalla con detalle para recibir actualizaciones, y
• fapunta al nombre de archivo que me gustaría darle al archivo.

El *es lo que le indica a tar que incluya todos los archivos y directorios locales de forma recursiva.

$ tar cvf nombredearchivo.tar *
archivo1
archivo2
archivo3
directorio1
directorio1/mascosas
directorio1/mascosas/archivo100
directorio1/mascosas/archivo101

El comando tar nunca moverá ni eliminará ninguno de los directorios y archivos originales que le proporciones, solo hace copias archivadas.

También debes tener en cuenta que el uso de un punto (.) en lugar de un asterisco (*) en el comando anterior incluiría incluso archivos ocultos (cuyos nombres de archivo comienzan con un punto) en el archivo.

Si lo estás haciendo en tu propio ordenador (como deberías), verás un nuevo archivo llamado nombredearchivo.tar. La extensión de nombre de archivo .tar no es necesaria, pero siempre es una buena idea comunicar claramente el propósito de un archivo de tantas formas como sea posible.

Extraer tu archivo para restaurar los archivos es fácil: simplemente usa xvfen lugar de cvf. Eso, en el ejemplo, guardará nuevas copias de los archivos y directorios originales en la ubicación actual.

$ tar xvf nombredearchivo.tar
archivo1
archivo2
archivo3
directorio1
directorio1/mascosas
directorio1/mascosas/archivo100
directorio1/mascosas/archivo101

Por supuesto, también puedes hacer que tar envíe sus archivos extraídos a algún otro lugar usando el argumento -C, seguido de la ubicación de destino:

$ tar xvf nombredearchivo.tar -C /home/misdatos/archivosantiguos/

No siempre querrás incluir todos los archivos dentro de un árbol de directorios en tu archivo.

Supongamos que has producido algunos videos, pero actualmente están guardados en directorios junto con todo tipo de archivos gráficos, de audio y de texto (que contienen tus notas). Los únicos archivos que necesitas respaldar son los clips de video finales con la extensión de nombre de archivo .mp4.

Así es como se hace:

$ tar cvf nombredearchivo.tar *.mp4

Genial. Pero esos archivos de video son enormes. ¿No sería bueno hacer ese archivo un poco más pequeño usando compresión?

¡No digas más! Simplemente, ejecuta el comando anterior con el argumento z (zip). Eso le dirá al programa gzip que comprima el archivo.

Si deseas seguir la convención, también puedes agregar una extensión .gz además de la .tarque ya existe. Recuerda: claridad.

Así es como se haría:

$ tar czvf nombredearchivo.tar.gz *.mp4

Si pruebas esto en tus propios archivos .mp4 y luego ejecutas ls -l en el directorio que contiene los nuevos archivos, puedes notar que el archivo .tar.gz no es mucho más pequeño que el archivo .tar, quizás un 10% más o menos. ¿Por qué?

Bueno, el formato .mp4 del archivo está comprimido, por lo que hay mucho menos margen para que gzip haga su trabajo.

Como tar es plenamente consciente de tu entorno Linux, puedes usarlo para seleccionar archivos y directorios que están fuera de tu directorio de trabajo actual. Este ejemplo agrega todos los archivos .mp4 en el directorio /home/miusuario/Videos/:

$ tar czvf archivename.tar.gz /home/myuser/Videos/*.mp4

Debido a que los archivos de almacenamiento pueden aumentar de tamaño, a veces puede tener sentido dividirlos en varios archivos más pequeños, transferirlos a su nuevo destino y luego volver a crear el archivo original en el otro extremo. La herramienta de división está hecha para este propósito.

En este ejemplo, -b le dice a Linux que divida el archivo nombredearchivo.tar.gz en partes de 1 GB. Luego, la operación nombra cada una de las partes: nombredearchivo.tar.gz.partaa, nombredearchivo.tar.gz.partab, nombredearchivo.tar.gz.partac, etc.:

$ split -b 1G nombredearchivo.tar.gz "nombredearchivo.tar.gz.part"

Por otro lado, vuelve a crear el archivo leyendo cada una de las partes en secuencia (cat nombredearchivo.tar.gz.part*), luego redirige la salida a un nuevo archivo llamado nombredearchivo.tar.gz:

$ cat nombredearchivo.tar.gz.part* > nombredearchivo.tar.gz

Transmisión de archivos del sistema de archivos

Aquí es donde empieza lo bueno. Te mostraré cómo crear una imagen de archivo de una instalación de Linux en funcionamiento y transmitirla a una ubicación de almacenamiento remota, todo con un solo comando. Aquí está el comando:

# tar czvf - --one-file-system / /usr /var \
  --exclude=/home/andy/ | ssh username@10.0.3.141 \
  "cat > /home/username/workstation-backup-Apr-10.tar.gz"

En lugar de tratar de explicar todo eso de inmediato, usaré ejemplos más pequeños para explorarlo pieza por pieza.

Vamos a crear un archivo de los contenidos de un directorio llamado cosasimportantes que está lleno de, bueno, cosas realmente importantes:

$ tar czvf - cosasimportantes/ | ssh usuario@10.0.3.141 "cat > /home/usuario/misarchivos.tar.gz"
cosasimportantes/nombredearchivo1
cosasimportantes/nombredearchivo2
[...]
usuario@10.0.3.141's password:

Déjame explicarte este ejemplo. En lugar de ingresar el nombre del archivo justo después de los argumentos del comando (como lo has hecho hasta ahora), usé un guion (czvf -).

El guion envía datos a la salida estándar. Te permite enviar los detalles del nombre del archivo al final del comando y le dice a tar que espere el contenido de origen del archivo en su lugar.

Luego canaliza (|) el archivo comprimido sin nombre a un inicio de sesión ssh en un servidor remoto donde me pidieron mi contraseña.

El comando que va entre comillas ejecuta cat contra el flujo de datos de archivo, el cual escribió el contenido del flujo en un archivo llamado myfiles.tar.gz en mi directorio de inicio del host remoto.

Una ventaja de generar archivos de esta manera es que evita la sobrecarga de un paso intermedio. No hay necesidad de guardar temporalmente una copia del archivo en la máquina local. Imagina hacer una copia de seguridad de una instalación que ocupa 110 GB de sus 128 GB de espacio disponible. ¿Dónde iría el archivo?

Esto era solo un directorio de archivos. Supongamos que necesitas hacer una copia de seguridad de un sistema operativo Linux activo en una unidad USB para poder moverlo a una máquina separada y colocarlo en la unidad principal de esa máquina.

Partiendo de la base de que ya existe una instalación nueva de la misma versión de Linux en la segunda máquina, la próxima operación de copiar/pegar generará una réplica exacta de la primera.

NOTA: Esto no funcionará en una unidad de destino que aún no tenga instalado un sistema de archivos Linux. Para manejar esa situación, deberá usar dd.

El siguiente ejemplo crea un archivo comprimido en la unidad USB conocido como /dev/sdc1.

El argumento --one-file-system excluye todos los datos de cualquier sistema de archivos, además del actual. Esto significa que las pseudoparticiones como /sys/y /dev/no se agregarán al archivo. Si hay otras particiones que deseas incluir (como lo harás para /usr/y /var/en este ejemplo), deben agregarse explícitamente.

Finalmente, puedes excluir datos del sistema de archivos actual usando el argumento --exclude:

# tar czvf /dev/sdc1/workstation-backup-Apr-10.tar.gz \
  --one-file-system \
  / /usr /var \
  --exclude=/home/usuario/

Ahora volvamos a ese ejemplo de comando de servicio completo. Usando lo que ya aprendiste, archiva todos los directorios importantes de un sistema de archivos y copia el archivo en una unidad USB. Debería tener sentido para ti ahora:

# tar czvf - --one-file-system / /usr /var \
  --exclude=/home/usuario/ | ssh usuario@10.0.3.141 \
  "cat > /home/usuario/workstation-backup-Apr-10.tar.gz"

Hay muchas más bondades de administración en forma de libros, cursos y artículos disponibles en mi bootstrap-it.com.

Un Symlink (también llamado enlace simbólico) es un tipo de archivo en Linux que apunta a otro archivo o carpeta del ordenador. Los enlaces simbólicos son similares a los accesos directos en Windows.

Algunas personas llaman a los enlaces simbólicos "enlaces blandos", un tipo de enlace en los sistemas Linux/UNIX, en lugar de "enlaces duros".

Diferencia entre un enlace blando y un enlace duro

Los enlaces blandos son similares a los accesos directos y pueden apuntar a otro archivo o directorio en cualquier sistema de archivos.

Los enlaces duros también son accesos directos para archivos y carpetas, pero no se puede crear un enlace duro para una carpeta o archivo en un sistema de archivos diferente.

Veamos los pasos necesarios para crear y eliminar un enlace simbólico. También veremos qué son los enlaces rotos y cómo eliminarlos.

Cómo crear un enlace simbólico

La sintaxis para crear un enlace simbólico es:

ln -s <ruta al archivo/carpeta para enlazar> <la ruta del enlace donde será creado>

ln es el comando de enlace. El parámetro -s especifica que el enlace debe ser blando. -stambién se puede escribir como -symbolic.

Por defecto, el comando ln crea enlace duro. El siguiente argumento es ruta al archivo (o carpeta) que desea vincular. (Es decir, la ruta al archivo o carpeta para el que desea crear un acceso directo).

Y el último argumento es la ruta del enlace (la ruta para el acceso directo).

Cómo crear un enlace simbólico para un archivo: comando de ejemplo

ln -s /home/james/transacciones.txt trans.txt

Después de ejecutar este comando, podrá acceder al archivo /home/james/transacciones.txt con trans.txt. Cualquier modificación a trans.txttambién se reflejará en el archivo original.

Tenga en cuenta que el comando anterior creará el archivo de enlace trans.txt en su directorio actual. También puede crear un archivo vinculado dentro de una carpeta:

ln -s /home/james/transactions.txt mis-cosas/trans.txt

Debe haber un directorio llamado "mis-cosas" en su directorio actual; de lo contrario, el comando generará un error.

Cómo crear un enlace simbólico para una carpeta: comando de ejemplo

Parecido a lo anterior, usaríamos:

ln -s /home/james james

Esto crearía una carpeta con enlazada simbólicamente llamada 'james' que contendría el contenido de /home/james. Cualquier cambio en esta carpeta vinculada también afectará a la carpeta original.

Cómo eliminar un enlace simbólico

Antes de querer eliminar un enlace simbólico, es posible que desee confirmar que un archivo o carpeta es un enlace simbólico, para que no manipule sus archivos.

Una forma de hacerlo es:

ls -l <ruta-a-supuesto-enlace-simbólico>

Ejecutando este comando en su terminal mostrará las propiedades del archivo. En el resultado, si el primer carácter es una letra L minúscula ('l'), significa que el archivo/carpeta es un enlace simbólico.

También verá una flecha (->) al final que indica el archivo/carpeta al que apunta el enlace simbólico.

Hay dos métodos para eliminar un enlace simbólico:

Cómo usar Unlink para eliminar un enlace simbólico

La sintaxis es:

unlink <ruta-al-enlace-simbólico>

Esto elimina el enlace simbólico si el proceso tiene éxito.

Aunque el enlace simbólico tenga la forma de una carpeta, no agregue '/', porque Linux asumirá que es un directorio y unlink no puede eliminar directorios.

Cómo usar rm para eliminar un enlace simbólico

Como hemos visto, un enlace simbólico es solo otro archivo o carpeta que apunta a un archivo o carpeta original. Para eliminar esa relación, puede eliminar el archivo vinculado.

Por lo tanto, la sintaxis es:

rm <ruta-al-enlace-simbólico>

Por ejemplo:

rm trans.txt
rm james

Tenga en cuenta que intentar hacer rm james/dará un error, porque Linux asumirá que 'james/' es un directorio, lo que requeriría otras opciones como ry f. Pero eso no es lo que queremos. Un enlace simbólico puede ser una carpeta, pero solo nos preocupa el nombre.

El principal beneficio de rm sobre unlink es que puede eliminar varios enlaces simbólicos a la vez, como puede hacer con los archivos.

Cómo encontrar y eliminar enlaces rotos

Los enlaces se rompen cuando el archivo o la carpeta a la que apunta un enlace simbólico cambia de ruta o se elimina.

Por ejemplo, sí 'transacciones.txt' se mueve de /home/jamesa /home/james/personal, el enlace 'trans.txt' se rompe. Cada intento de acceder al archivo resultará en un error 'No existe el archivo o directorio'. Esto se debe a que el enlace no tiene contenido propio.

Cuando descubra enlaces rotos, puede eliminar fácilmente el archivo. Una manera fácil de encontrar enlaces simbólicos rotos es:

find /home/james -xtype l

Esto enumerará todos los enlaces simbólicos rotos en el directorio james, desde archivos hasta directorios y subdirectorios.

Con la opción-delete los eliminará:

find /home/james -xtype l -delete

Conclusión

Los enlaces simbólicos son una característica interesante de los sistemas Linux y UNIX.

Puede crear enlaces simbólicos de fácil acceso para hacer referencia a un archivo o carpeta a los que de otro modo no sería conveniente acceder. Con un poco de práctica, comprenderá cómo funcionan a un nivel intuitivo y lo harán mucho más eficiente en la administración de sistemas de archivos.

Si más de una persona está usando su máquina Linux en casa, o si estás administrando un servidor que brinda acceso a múltiples usuarios, el comando useradd  es esencial para crear nuevos usuarios.

Además, muchos de los servicios que utilizas como desarrollador pueden requerir sus propias cuentas de usuario para funcionar. Entonces, incluso como desarrollador independiente en tu propia máquina es posible que busques estos comandos cuando instales MySQL o algo similar.

Puedes obtener una descripción general completa de las diversas opciones disponibles viendo la documentación del manual de la utilidad: man useradd.

Pero si eso resulta abrumador, aquí hay un desglose de algunas de las opciones comunes que puedes usar al crear un usuario.

Crear un usuario

El formato simple para este comando es useradd [opciones] NOMBREDEUSUARIO.

Por ejemplo: useradd test (anteponer sudo si no has iniciado sesión como usuario root).

Esto creará un usuario llamado test, pero es una operación limitada y no generará otras cosas útiles como su carpeta de inicio (home), o su palabra clave (password).

Añadir una palabra clave

Luego puedes añadir una palabra clave para el usuario test usando el comando: passwd test. A continuación te pedirá que ingreses una palabra clave para el usuario.

Hay una opción para añadir una palabra clave encriptada a través de la opción -p en useradd, pero no es recomendable por razones de seguridad.

Ten en cuenta que la opción -p no te permite ingresar una palabra clave como texto sin formato, sino que espera que lo encriptes primero. Esto es intencionalmente difícil porque no deberías hacerlo. Simplemente, utiliza el comando passwd.

Otras opciones comunes

Carpetas de inicio

Para crear un usuario con la carpeta de inicio predeterminada (home) utiliza la siguiente opción:

useradd -m test

Este usuario ahora tiene una carpeta /home/test.

Para crear la carpeta de inicio con otro nombre puedes utilizar la opción -d, por ejemplo, del siguiente modo:

useradd -m -d /nombre-de-carpeta test

Shell (intérprete de comandos)

De manera predeterminada, es probable que tus usuarios creados tengan el shell de inicio de sesión bin/bash o bin/sh, que estará definido en /etc/default/useradd.

Puedes anular este valor predeterminado y definir otro con la opción -s del siguiente modo:

useradd -s usr/bin/zsh test

Poniéndolo todo junto

Para construir el comando completo, tienes que poner las opciones una tras otra - sin importar el orden - y terminal con el nombre de usuario que quieres crear.

Entonces, crear un usuario con una carpeta de inicio "home" y un shell personalizado se vería así:

useradd -m -s /usr/bin/zsh user

Y luego tendrías que añadir una palabra clave para el usuario: passwd user

Lee el manual

Ahora que has visto lo básico de lo que puede hacer esta herramienta, esperamos que la página man sea un poco navegable.

man useradd te mostrará como añadir cosas, como una fecha de vencimiento de la cuenta, asignar grupos, entre otras.

Desde la creación de Unix en la década de 1970, muchos sistemas operativos lo han utilizado como base. Muchos de estos sistemas operativos fallaron, mientras que otros tuvieron éxito.

Linux es uno de los sistemas operativos basados en Unix más populares. Es de código abierto y se utiliza en todo el mundo en muchas industrias.

Una característica sorprendente del sistema operativo Linux es la Interfaz de Línea de Comandos (CLI) que permite a los usuarios interactuar con su computadora desde un shell. El shell de Linux es un entorno REPL (Lectura, Evaluación, Impresión, Bucle) donde los usuarios pueden introducir un comando y el shell lo ejecuta y devuelve un resultado.

El comando ls es uno de los muchos comandos de Linux que permiten a un usuario listar archivos o directorios desde la CLI.

En este artículo, profundizaremos en el comando ls y algunas de las banderas más importantes que necesitarás en el día a día.

Requisitos

• Una computadora con directorios y archivos
• Tener instalada una de las distribuciones de Linux
• Conocimientos básicos de navegación por el CLI
• Una sonrisa en tu cara :)

El Comando Linux ls

El comando ls se utiliza para listar archivos o directorios en Linux y otros sistemas operativos basados en Unix.

Al igual que navegas en tu explorador de archivos o finder con una interfaz gráfica de usuario, el comando ls te permite enumerar todos los archivos o directorios en el directorio actual de forma predeterminada, e interactuar con ellos a través de la línea de comandos.

Inicia tu terminal y escribe ls para ver esto en acción:

Cómo listar archivos en un directorio con opciones

El comando ls también acepta algunos indicadores (también conocidos como opciones) que son información adicional que cambia la forma en que se listan los archivos o directorios en su terminal.

En otras palabras, los indicadores cambian el funcionamiento del comando ls:

 ls [indicadores] [directorio]

PD: ¿La palabra contenido utilizado en todo el artículo se refiere a los archivos y directorios que se listan, no al contenido real de los archivos/directorios?

Lista de archivos en el directorio de trabajo actual

Escriba el comando ls para listar el contenido del directorio de trabajo actual:

Lista de archivos en otro directorio

Escribe el comando ls [ruta de directorio aquí] para listar el contenido de otro directorio:

Lista de archivos en el directorio raíz

Escriba el comando ls / para listar el contenido del directorio raíz:

Lista de archivos en el directorio padre

Escribe el ls .. comando para listar el contenido del directorio padre un nivel más arriba. Usa ls ../.. para contenidos dos niveles arriba:

Lista de archivos en el directorio personal del usuario (/home / user)

Escribe el comando ls ~ para listar el contenido en el directorio personal del usuario:

Listar solo directorios

Escriba el comando ls -d */ para listar solo los directorios:

Lista de archivos con subdirectorios

Escriba el comando ls * para listar el contenido del directorio con sus subdirectorios:

Lista de archivos recursivamente

Escribe el comando ls -R para listar todos los archivos y directorios con sus subdirectorios correspondientes hasta el último archivo:

Si tiene muchos archivos, puede tardar mucho tiempo en completarse, ya que se imprimirán todos los archivos de cada directorio. En su lugar, puedes especificar un directorio para ejecutar este comando, de la siguiente manera: ls Downloads -R

Lista de archivos con sus tamaños

Escriba el comando ls -s (la s es minúscula) para listar archivos o directorios con sus tamaños:

Lista de archivos en formato largo

Escriba el comando ls -l para listar el contenido del directorio en un formato de tabla con columnas incluidas:

• permisos de contenido
• número de enlaces al contenido
• propietario del contenido
• propietario del grupo del contenido
• tamaño del contenido en bytes
• fecha / hora de la última modificación del contenido
• nombre de archivo o directorio

Lista de archivos en formato largo con tamaños de archivo legibles

Escribe el comando ls -lh para listar los archivos o directorios en el mismo formato de tabla anterior, pero con otra columna que represente el tamaño de cada archivo/directorio:

Ten en cuenta que los tamaños se enumeran en bytes (B), megabytes (MB), gigabytes (GB) o terabytes (TB) cuando el tamaño del archivo o directorio es superior a 1024 bytes.

Lista de archivos, incluidos los archivos ocultos

Escribe el comando ls -a para listar archivos o directorios, incluidos archivos o directorios ocultos. En Linux, cualquier cosa que comience con un . se considera un archivo oculto:

Lista de archivos en formato largo, incluidos los archivos ocultos

Escriba el comando ls -l -a o ls -a -l o ls -la o ls -al para listar archivos o directorios en un formato de tabla con información adicional, incluidos archivos o directorios ocultos:

Listar archivos y ordenar por fecha y hora

Escribe el comando ls -t para listar archivos o directorios y ordenar por fecha de última modificación en orden descendente (de mayor a menor).

También puedes agregar el indicador -r para invertir el orden de clasificación de la siguiente manera: ls -tr:

Lista de archivos y ordenar por tamaño de archivo

Escribe el comando ls -S (la S es mayúscula) para listar archivos o directorios y ordenar por tamaño en orden descendente (de mayor a menor).

También puedes agregar un indicador -r para invertir el orden de clasificación de la siguiente manera: ls -Sr:

Listar archivos y generar el resultado en un archivo

Escriba la salida ls > output.txt para imprimir el resultado del comando anterior en un archivo output.txt. Puedes usar cualquiera de los indicadores discutidos antes como -la — el punto clave aquí es que el resultado se generará en un archivo y no se registrará en la línea de comandos.

A continuación, puede usar el archivo como mejor le parezca, o registrar el contenido del archivo con cat output.txt:

Conclusion

Hay toneladas de otros comandos y combinaciones que puedes explorar para enumerar archivos y directorios en función de tus necesidades. Una cosa a recordar es la capacidad de combinar varios comandos a la vez.

Imagina que deseas enumerar un archivo en formato largo, incluyendo los archivos ocultos, y ordenarlos por tamaño de archivo. El comando ls -alS, que es una combinación de ls -l, ls -a y ls -S.

Si olvidas algún comando o no estás seguro de qué hacer, puedes ejecutar ls --help o man ls, que mostrará un manual con todas las opciones posibles para el comando ls:

Gracias por leer!

grep tiene muchas opciones que permiten realizar varias acciones relacionadas con la búsqueda en archivos. En este artículo, observaremos como usar el comando grep con sus opciones disponibles tanto como expresiones regulares básicas para buscar archivos.

Cómo usar grep

Sin el paso de ninguna opción, grep puede ser usado para buscar un patrón en un archivo o grupo de archivos. La sintaxis es:

grep '<texto-buscado>' <archivo/archivos>

Tenga en cuenta que las comillas simples o dobles son requeridas alrededor del texto si es más de una palabra.

Tú puedes además usar el comodín (*) para seleccionar todos los archivos en un directorio.

El resultado de esto son las ocurrencias del patrón (por la línea en la que se encuentra) en los archivos. Si no existe una coincidencia, no se imprimirá ninguna salida en la terminal.

Por ejemplo, supongamos que tenemos los siguientes archivos (llamados grep.txt):

Hello, how are you
I am grep
Nice to meet you

El siguiente comando grep buscará todas las ocurrencias de la palabra "you":

grep you grep.txt

El resultado será:

Hello, how are you
Nice to meet you

you se espera que tenga un color diferente al del otro texto para identificar fácilmente lo que se buscó.

Pero grep viene con más opciones que nos ayudan a lograr más durante la operación de búsqueda. Veamos nueve de ellos mientras los aplicamos al ejemplo anterior.

Opciones usadas con grep

1. -n (--line-number) - enumera los números de línea

Imprime las coincidencias de un texto junto con los números de línea. Si observas el resultado anterior, notarás que no se encuentran los números de líneas, solo las coincidencias.

grep you grep.txt -n

Resultado:

1: Hello, how are you
3: Nice to meet you

2. -c (--count) - imprime el número de líneas de coincidencias

grep you grep.txt -c

Resultado:

2

Tenga en cuenta si existiera otro "you" en la línea uno, la opción -c  aún imprimiría 2. Esto porque está relacionada con el número de líneas donde aparecen las coincidencias, no la cantidad de coincidencias.

3. -v (--invert-match) - imprime las líneas que no coinciden con el patrón especificado

grep you grep.txt -v -n

Resultado:

2. I am grep

Notaste que nosotros usamos también la opción  -n? Si, es posible usar múltiples opciones en un solo comando.

4. -i (--ignore-case) - Utilizado para la distinción de mayúsculas y minúsculas

# comando 1
grep You grep.txt
# comando 2
grep YoU grep.txt -i

Resultado:

# resultado 1
# no hay resultados
# resultado 2
Hello, how are you
Nice to meet you

5. -l (--files-with-matches) - imprimir nombres de archivos que coincidan con un patrón

# comando 1
grep you grep.txt -l
# comando 2
grep You grep.txt -i -l

Resultado:

# resultado 1
grep.txt
# resultado 2
# todos los archivos en el directorio actual que coincidan
# el texto 'You' sea mayúscula o minúscula

#### 6. `-w` (--word-regexp) - imprime coincidencias de toda la palabra

Por defecto, grep coincide con cadenas que contienen el patrón especificado. Esto significa que grep yo grep.txt imprimirá los mismos resultados que  grep yo grep.txt porque 'yo' puede ser encontrado en 'you'. Similarmente 'ou'.

Con la opción -w, grep se asegura que las coincidencias sean exactamente el mismo patrón especificado, Ejemplo:

grep yo grep.txt -w

Resultado:

Sin resultados!

7. -o (--only-matching) - imprimir solo el patrón coincidente

Por defecto, grep imprime la línea donde se encuentra el patrón que coincide. Con la opción -o , solo los patrones que coincidan son impresos línea por línea. Ejemplo:

grep yo grep.txt -o

Resultado:

yo

8. -A (--after-context) y -B (--before-context) - imprimir las líneas después y antes (respectivamente) del patrón coincidente

grep grep grep.txt -A 1 -B 1

Resultado:

Hello, how are you
I am grep
Nice to meet you

Esta coincidencia de patrón se encuentra en la línea 2. -A 1 significa una línea después de la línea que coincide y -B 1 significa una línea antes de la línea que coincide.

Además existe -C (--context) opción el cual es igual a -A + -B.  El valor pasado a -C se usaría para -A y -B.

9. -R (--dereference-recursive) - búsqueda recursiva

Por defecto, grep no puede buscar directorios. Si tú intentas hacerlo, obtendrás un error ("Es un directorio"). Con la opción  -R, la búsqueda de archivos entre directorios y subdirectorios se vuelve posible. Ejemplo:

grep you .

Resultado:

# 'you' coincide en carpetas
# y archivos a partir del
# directorio actual

Expresiones regulares para patrones

grep también permite especificar patrones con expresiones regulares básicas. Dos de ellas son:

1. ^pattern - Inicio de línea

Este patrón significa que grep solo coincide con cadenas cuyas líneas empiecen con la cadena especificada después ^. Ejemplo:

grep ^I grep.txt -n

Resultado:

2: I

2. pattern$ - fin de la línea

En contraste con  ^, $ especifica patrones que coincidirán si la línea termina con la cadena antes $. Ejemplo:

grep you$ grep.txt

Resultado:

1: Hello, how are you
3: Nice to meet you

Resumen

grep es una herramienta poderosa para la búsqueda de archivos en la terminal.

Entender como usarlo te brinda la habilidad de encontrar fácilmente archivos por medio de la terminal.

Existen más opciones relacionadas con esta herramienta. Puedes encontrarlas con el comando man grep.

Traducido del artículo de  - Dillion Megida - Grep Command Tutorial – How to Search for a File in Linux and Unix with Recursive Find

Cómo instalar y configurar un servidor FTP en Linux Redhat/CentOS

Paso 1: Usaremos localhost (127.0.0.1) en nuestro equipo para configurar el servidor ftp.

Paso 2: Instalar el paquete vsftpd (muy seguro FTP daemon).

yum install -y vsftpd

Paso 3: Inicia el servidor FTP cuando el sistema esté encendido.

systemctl enable vsftpd.service

Paso 4: Comprobar el estado del servidor de FTP.

systemctl status vsftpd.service

Paso 5: Configura el paquete vsftpd. Editaremos /etc/vsftpd/vsftpd.conf

// Cambia la línea que contiene anonymous_enable=NO a
anonymous_enable=YES

Esto le permitirá a cualquiera acceder al servidor FTP con autenticación.

// Cambie lo siguiente a YES
local_enable=YES
write_enable=YES<br>

Paso 6: Inicia el servidor FTP.
systemctl start vsftpd.service

Paso 7: Instala el cliente de FTP.
yum install -y lftpd

Paso 8: Conecta el FTP al localhost.
lftp localhost

Traducido del artículo - Install and configure an FTP server in Redhat/Centos Linux

Esto te permitirá trabajar utilizando PHP y MySQL (mediante phpMyAdmin), herramientas comúnmente necesarias para el desarrollo en Wordpress.

Instalando los paquetes necesarios

Necesitarás instalar los siguientes paquetes para el servidor LAMP. Puedes instalarlos todos juntos separando el nombre de cada paquete con un espacio, o uno a la vez como se mostrará aquí.

Yo prefiero descargarlos uno a la vez, ya que simplifica la detección de errores.

Abre una terminal y teclea lo siguiente:

• sudo apt-get install apache2
• sudo apt-get install php
• sudo apt-get install php-mysql
• sudo apt-get install mysql-server

Se te solicitará establecer una contraseña para el usuario raíz de MySQL. Una vez hecho esto, prosigue con la instalación tecleando:

• sudo apt-get install libapache2-mod-php
• sudo apt-get install php-mcrypt
• sudo apt-get install phpmyadmin

Deberás elegir que servidor utilizar. Selecciona Apache presionando la tecla enter. Selecciona no para configuración avanzada del servidor.

Cambiando permisos al directorio /var/www/html

Para que los scripts y archivos PHP puedan ser ejecutados por el servidor LAMP deberán ser almacenados en el directorio /var/www/html. Puedes considerar esta ubicación como tu servidor local.

Tendremos que cambiar los permisos de este directorio para que se nos permita hacer cambios en él. Ingresa en la terminal este comando:

sudo chown {tu usuario ubuntu} /var/www/html

Creando un enlace simbólico a phpMyAdmin

De manera predeterminada, phpMyAdmin se instala en el directorio /usr/share. Necesitamos enlazarlo al directorio de nuestro servidor local.

Nos dirigimos al directorio del servidor en donde queremos el enlace con:               cd /var/www/html

Creamos entonces el enlace simbólico ingresando el comando ln -s /usr/share/phpmyadmin phpmyadmin.

Reiniciando Apache y probando

Ejecuta el siguiente comando para reiniciar Apache, estableciendo los cambios que hemos realizado:

sudo systemctl restart apache2

Ahora deberás ser capaz de crear un archivo info.php en el directorio /var/www/html con el comando: touch /var/www/html/info.php

Añade al archivo el siguiente código:

<?php phpinfo(); ?>

Ahora, abre un navegador y escribe en la barra de direcciones localhost/info.php. Deberás ver una página generada por el archivo creado que muestra información sobre PHP.

Finalmente, para acceder a phpMyAdmin dirígete a localhost/phpmyadmin en el navegador. El nombre del usuario raíz por defecto es 'root' y la contraseña será la que definiste anteriormente para la base de datos MySQL.

Traducido del artículo: How to Setup a LAMP Server on a Local Ubuntu Linux Machine or VM

Algunas personas llaman a los enlaces simbólicos  "soft links" - un tipo de enlace en los sistemas Linux/UNIX - opuestos a los "hard links".

Diferencia entre un soft link y un hard link

Los soft Links son similares a los accesos directos, pueden apuntar a otro archivo o directorio en cualquier sistema de archivos.

Los hard links también son accesos directos para archivos y carpetas, pero no se puede crear un hard link para una carpeta o un archivo en un sistema de archivos diferente.

Veamos los pasos para crear y eliminar un enlace simbólico. También veremos qué son los enlaces rotos y cómo eliminarlos.

Cómo crear un enlace simbólico

La sintaxis para crear un enlace simbólico es:

ln -s <ruta del archivo/Carpeta a ser enlazado> <ruta del enlace que se creará>

ln es el comando de enlace. La bandera -s especifica que el enlace debe ser soft. Las -s también pueden ser introducidas como -symbolic.

Por defecto, el comando ln crea hard links. El siguiente argumento es la ruta del archivo (o carpeta) que quieres enlazar. (Es decir, el archivo o carpeta para el acceso directo que quieres crear).

El último argumento es la ruta para enlazarse a sí mismo (el acceso directo).

Cómo crear un enlace simbólico para un archivo - comando de ejemplo

ln -s /home/james/transacciones.txt trans.txt

Después de ejecutar este comando, tú podrías acceder a /home/james/transacciones.txt con trans.txt. Cualquier modificación en el trans.txt también se reflejará en el archivo original.

Tenga en cuenta que este comando de arriba crearía el archivo de enlace trans.txt en su directorio actual. Tú también puedes crear un archivo de enlace en una carpeta que enlace esto:

ln -s /home/james/transacciones.txt mis-cosas/trans.txt

Debe haber un directorio ya llamado "mis-cosas" en su directorio actual - si no, el comando arrojará un error.

Cómo crear un enlace simbólico para una carpeta - comando de ejemplo

Como en el caso anterior, usaríamos:

ln -s /home/james james

Esto crearía una carpeta simbólica llamada 'james' que contendría el contenido de /home/james. Cualquier cambio en esta carpeta vinculada también afectará a la carpeta original.

Cómo remover un enlace simbólico

Antes de que tú quieras eliminar un enlace simbólico, tú puedes confirmar que un archivo o una carpeta es un enlace simbólico, para no manipular tus archivos.

Una forma de hacer esto es:

ls -l <ruta-a-ser-enlace-simbolico>

Al ejecutar este comando en tu terminal, se mostrarán las propiedades del archivo. En el resultado, si el primer carácter es una L minúscula ('l'), significa que el archivo/carpeta es un enlace simbólico.

También verías una flecha (->) al final que indica el archivo/carpeta al que apunta el enlace del símbolo.

Hay dos métodos para eliminar un enlace simbólico:

Cómo usar unlink para eliminar un enlace simbólico

La sintaxis es:

unlink <ruta-enlace-simbolico>

Esto elimina el enlace simbólico, si el proceso tiene éxito.

Incluso si el enlace simbólico tiene forma de carpeta, no añada '/', porque Linux asumirá que es un directorio y el unlink no puede borrar directorios.

Cómo usar rm para remover un symlink

Como hemos visto, un enlace simbólico es sólo otro archivo o carpeta que apunta a un archivo o carpeta original. Para eliminar esa relación, tú puedes eliminar el archivo enlazado.

Por lo tanto, la sintaxis es:

rm <ruta-enlace-simbolico>

Por ejemplo:

rm trans.txt
rm james

Tengan en cuenta que intentar hacer rm james/ resultaría un error, porque Linux asumirá que 'james/' es un directorio, lo que requeriría otras opciones como r y f. Pero eso no es lo que queremos. Un enlace simbólico puede ser una carpeta, pero sólo nos interesa el nombre.

El principal beneficio de rm sobre unlink es que tú puedes eliminar múltiples enlaces simbólicos a la vez, como tú puedes hacer con los archivos.

Cómo encontrar y eliminar los enlaces rotos

Los enlaces rotos se producen cuando el archivo o la carpeta a la que apunta un enlace simbólico cambia de ruta o se elimina.

Por ejemplo, si "transactions.txt" dentro de la carpeta /home/james, se mueve de /home/james a /home/james/personal, el enlace "transaction.txt" se rompe. Cada intento de acceder al archivo resultará en un error de "No existe tal archivo o directorio". Esto se debe a que el enlace no tiene contenido propio.

Cuando tú descubras enlaces rotos, tú puedes borrar el archivo fácilmente. Una forma fácil de encontrar enlaces simbólicos rotos es:

find /home/james -xtype l

Esto listará todos los enlaces simbólicos rotos en el directorio james - desde los archivos a los directorios y sub-directorios.

Pasando la opción -delete los borrará así:

find /home/james -xtype l -delete

En resumen

Los enlaces simbólicos son una característica interesante de los sistemas Linux y UNIX.

Tú puedes crear enlaces simbólicos de fácil acceso para referirse a un archivo o carpeta a la que de otra manera no sería conveniente acceder. Con un poco de práctica, tú comprenderás cómo funcionan a nivel intuitivo y te harán más eficiente la gestión de los sistemas de archivos.

Traducido del artículo - Symlink Tutorial in Linux – How to Create and Remove a Symbolic Link de Dillion Megida

Los grupos se usan con frecuencia para permitir que ciertos usuarios modifiquen un archivo o directorio.

Los dos tipos de grupos principales son grupos primarios y grupos secundarios. El grupo primario de un usuario es el grupo por defecto con el que se asocia la cuenta, generalmente comparte el mismo nombre que el usuario. Los directorios y los archivos que el usuario crea tendrán asignados este grupo. Un grupo secundario es cualquier grupo adicional del que un usuario sea parte.

Creación de grupos

Creemos dos grupos llamados "writers" y "editors". Usa el comando groupadd (es posible que necesites usar el comando sudo al inicio para tener el permiso adecuado para crear el grupo):

groupadd writers
groupadd editors

Creación de usuarios

Puede que ya tengas usuarios para agregar a tu grupo. Si no, aquí está la sintaxis básica para crear un usuario con el comando useradd:

useradd [options] username

Aquí está para crear un usuario llamado "quincy". El argumento -m le dice al comando que cree el directorio principal del usuario con el mismo nombre que el usuario. El argumento con su valor -p p4ssw0rd crea la contraseña "p4ssw0rd" para el usuario.

useradd -m quincy -p password

Los usuarios serán capaces de cambiar su contraseña con el comando passwd. Para ello, tendrán que ingresar su contraseña actual en ese momento y luego definir una nueva.

Agregar un usuario a un grupo

Puedes usar el comando usermod para agregar un usuario a un grupo. Así es cómo agregaríamos el usuario "quincy" al grupo "writers". El argumento -a significa "añadir" (append) y el argumento -G agrega un grupo como un grupo secundario.

usermod -a -G writers quincy

Cuando un usuario es creado con el comando adduser, este es automáticamente asignado a un grupo primario con el mismo nombre que el usuario. En nuestro ejemplo, actualmente el usuario "quincy" es parte de un grupo primario "quincy" y de un grupo secundario "writers".

También puedes agregar un usuario a muchos grupos a la vez al separar por comas los nombres de los grupos, así -G group1,group2,group3.

El siguiente comando cambia el grupo primario del usuario "quincy" de "quincy" a "editors":

usermod -g editors quincy

Remover un usuario de un grupo secundario

Para remover un usuario de un grupo secundario necesitas sobreescribir los grupos a los que actualmente este usuario pertenece, por una nueva lista de grupos dónde no esté el grupo que se quiere remover.

Primero, usa el comando id para verificar a cuáles grupos secundarios pertenece un usuario:

id -nG quincy

Digamos que este comando nos devuelve editors writers, esto indica que el usuario "quincy" es parte de los grupos "editors" y "writers". Si quieres remover al usuario del grupo "writers", usa el comando:

usermod -G editors quincy

Ese comando establece como grupo secundario del usuario "quincy" como "editors". Ya que el argumento -a no fue usado, los grupos previos fueron sobreescritos.

Conclusión

Deberías ahora estar listo para manejar usuarios y grupos en Linux. El siguiente paso es determinar qué privilegios debería tener cada grupo.

Traducido del artículo de Beau Carnes - Linux User Groups Explained: How to add a new group, a new group member, and change groups