---
# System prepended metadata

title: Fundamentos de línea de comandos
tags: [talleres_mln]

---

# Fundamentos de línea de comandos
###### tags: `talleres_mln`

Este es un tutorial básico para usar la terminal o más comunmente llamada línea de comandos tan habitual en sistemas Unix y Linux.
Está orientado a cubrir sólo los comandos que suelen ser los más usados al momento de interactuar con nodos de Bitcoin y Lightning Network.

**Tabla de contenido**
[TOC]

## Autor
Twitter para correcciones, comentarios o sugerencias: [@bitao36](https://twitter.com/bitao36)

El presente tutorial fue elaborado para el [Seminario socrático de Mastering Lightning](https://libreriadesatoshi.com/) a través de [@libreriadesatoshi](https://twitter.com/libdesatoshi).

## Requerimientos :information_source: 
:::info
Tener instalada una distribución de Linux basada en Debian, preferiblemente Ubuntu. 
En  caso de que no dispongas de Linux abre el siguiente link https://killercoda.com/playgrounds/scenario/ubuntu
:::

## Que es la terminal o línea de comandos
La terminal es una interfaz que se utiliza para interactuar con el shell y el shell es el intérprete de comandos. Hay varios intérpretes de comandos el más usado es el shell  Bash (Bourne-again shell).
Para saber que shell estás usando abre una terminal y escribe:

```
$echo $SHELL
```
## Usuarios normales y root
Linux es un sistema operativo multiusuario,  existe un usuario llamado root que es superadministrador con todos los permisos de escritura y ejecución.
Como norma de seguridad no es aconsejable usar el usuario root para trabajar en sesiones habituales.


El prompt de la terminal indica si es la sesión de root o no. Si el prompt que ves es el siguiente símbolo:
```
$
``` 
Es un usuario normal. Si es el siguiente símbolo:

```
#
```
Entonces es la sesión de root.

Para saber que usuario estás usando puedes  ejecutar el comando

```
$whoami
```


Cuando veas tutoriales  que usen la terminal siempre presta atención al prompt que tiene antes del comando ya que este te indica si necesita ser ejecutado como root.


Lo que debemos hacer para trabajar en sesiones habituales es crear otros usuarios y en caso de que se necesite ejecutar algún comando que necesite permisos especiales otorgamos permisos a  ese usuario  añadiéndolo al grupo sudo en el caso de Ubuntu o con el comando visudo si estamos en Debian.

El comando para crear un usuario es:

```
$adduser <usuario>
```

y el comando para añadir un usuario a un grupo si estás en ubuntu es: 
```
$usermod -aG <grupo> <usuario>
```
Si estás en Debian como root ejecuta:
```
sudo visudo
```
y vas hasta donde dice
```
#User privilege specification
```
Y colocas lo siguiente:
```
<usuario> ALL=(ALL:ALL) ALL
```




## Como moverse por el árbol de directorios

![](https://hackmd.io/_uploads/rJHzTG_rn.jpg)


El directorio ```.``` es el directorio actual
El directorio ```..``` es el directorio padre
El directorio ```~``` es el directorio home del usuario actual y se puede obtener presionando F5


Para mirar el listado de archivos y directorios mostrando todos los atributos y el tamaño en un formato que pueda ser entendida por humanos usa el  comando ls con el modificador h

```$ls -lah```

Para cambiar de directorio  usa el comando:

```$cd directorio```

Para crear un directorio usa el comando:

```$mkdir```

Para saber la ruta en la que te encuentras usa el comando:

```$pwd```

### Ejercicio 1: 
:::info

Ubícate en tu carpeta home  y crea una carpeta llamada proyectos y dentro de esa carpeta crea dos carpetas una llamada documentos y otra desarrollo.

:::



## Permisos de archivos

![](https://hackmd.io/_uploads/ryasnfuH3.png)

Los tipos de archivo más comunes son:

```-```:Archivo regular
```d```:Directorio
```l```:Enlace simbólico
Los permisos son:
```r```: Lectura
```w```: Escritura
```x```: Ejecución




## Manejo de archivos

Para:

* Crear o editar: para editar archivos puedes usar nano o vim. Por lo general nano es mas sencillo de usar. Vim es más complejo de usar y es usado por lo general por usuarios avanzados ya que con buenos plugins puedes convertirlo en un editor de código de programación.
En este taller usaremos nano por simplicidad.

     ```$nano archivo```

* Copiar: se usa el comando cp. Hay un modificador muy importante cuando debe copiar una carpeta para que se copie con todos los archivos que tiene dentro a la nueva ruta. 

    ```$cp -r subcarpeta /home/user/nuevaruta```
* Cambiar el nombre de un archivo se usa 
 ```$mv nombrearchivo```

* Borrar un archivo se usa 
 ```$rm archivo```
 
* Mirar logs: 
 ```$tail -f archivolog.log```
 
### Ejercicio 2: 
:::info

Dentro de la carpeta proyectos creada en el ejercicio 1 crea los archivos tarea1.txt y data.dat y copialos en la carpeta documentos que tambien fué creada previamente.

:::
## Canalización o pipes

Los pipes son muy poderosos y por lo general la usan mucho los usuarios avanzados.
En esencia un pipe(tubería) envia la salida de un comando a la entrada de otro comando.

Por ejemplo, hay un comando llamado cat que sirve para mirar el contenido de archivos y hay un comando que sirve para paginar llamado less.

Vamos a ir a la carpeta /var/log y vamos a visualizar el archivo
```
$cd /var/log
$cat dpkg.log 
```

Como puedes ver el archivo tiene demasiadas lineas y no puedes ver las primeras. Por eso a continuación usaremos un pipe para poder mirar el archivo pagina por página:

```
$cat dpkg.log | less
```

Para ir avanzando se hace con espaciadora y para salir se presiona q

El siguiente comando envía el listado de archivos en el directorio a un archivo llamado listado.txt

```
$ls -lah > listado.txt
```
Si miramos el archivo listado observaremos que toda la salida del comando ls -lah fué almacenado en el archivo listado.txt
```
$cat listado.txt
```

### Ejercicio 3: 
:::info

Ejercicio: Crea un archivo con los siguientes numeros y ordénalos usando una canalización con el comando sort.
```
5 
3 
8 
7 
1
```

:::


## Gestión de procesos

### Que son y como listarlos 

Linux asigna a cada proceso que se ejecuta en el sistema un número entero llamado PID.

A veces es importante listar los procesos del usuario o simplemente conocer de algún proceso en particular. 
Para tener un listado de procesos del sistema ejecuta:

```
$ps -fe 
```

Si solo deseas procesos del usuario actual ejecuta

```
$ps fu
```

Si deseas buscar el proceso asociado a algún programa que has ejecutado puedes pasarselo con un pipe a  grep para que lo busque. 
Por ejemplo, si quieres saber si  Python3 está corriendo en tu sesión, ejecuta el siguiente comando:

```
$ps -fe | grep python 
```

### Como monitorear procesos y rendimiento


Es muy importante saber como mirar los procesos que está ejecutando el sistema, para saber que tan cargado está y saber que proceso en particular está gastando más recursos.

El comando más usado es htop, en caso de que no esté instalado ejecuta:

```
$sudo apt install htop
```

y luego lo ejecutas: 

```
$htop
```
Este comando arroja el listado de procesos y algunos parámetros. Hay un parámetro llamado Load average que nos indica que tan cargado esta el sistema. Su valor debe ser inferior al número de núcleos que tenga tu procesador.
En caso de que el sistema esté muy cargado puede que nisiquiera abra htop. En este tipo de casos puedes usar el comando:

```
$cat /proc/loadavg
```

En caso de que veamos que un proceso está consumiendo todo el procesador o la memoria podemos matarlo usando su PID con el siguiente comando:

```
$kill PID
```


## Gestión de varias terminales con tmux

Usualmente cuando empezamos a trabajar con la línea de comandos surge la necesidad de usar varias ventanas. Para no tener que abrir múltiples terminales, podemos usar una herramienta llamada tmux que nos permite dividir la terminal actual sin necesidad de abrir terminales extra.

Lo primero que debemos hacer es instalar tmux:

```
$sudo apt install tmux
```

Ahora ejecuta:

```
$tmux
```

Si quieres dividir la ventana de forma horizontal presionas 
Ctrl+B y luego SHIFT+" 
Y si quieres dividir la ventana de forma vertical presionas 
Ctrl+B y luego Shift+%
Si deseas pasar de una ventana a otra presiona Ctrl+B y flecha (arriba o abajo o izquierda o derecha) dependiendo de como te quieras mover.

### Ejercicio 4: 
:::info

Ejercicio: Crea un script en el home llamado msj.sh
```
$cd ~
$nano msj.sh
$chmod +x msj.sh
```
Y añade el siguiente contenido 
```
#!/bin/bash

while true; do
    echo "$(date '+%H:%M:%S') Bitcoin es libertad"
    sleep 2  # Pausa de 1 segundo antes de imprimir el siguiente mensaje
done
```
Usando tmux abre una terminal y ejecuta el script creado de la siguiente forma
```
$./msj.sh > salida.txt &
```
Ejecuta el siguiente comando para ver como se va llenando el archivo salida.txt
```
tail -f salida.txt
```

Abre otra terminal usando tmux y obtén el PID del proceso que ejecuta msj.sh y a continuación mata ese proceso

:::

## :zap: Donaciones
:::success
Si te fue útil este material puedes agradecer a  @bitao36, enviándole un aporte vía Lightning Address: 
bitao36@getalby.com
:::
