# **Unidad 2. Comandos básicos de Linux**
---
#### Dra. Laura Liliana López Galindo | lilopez@cicese.edu.mx | laura.lopez11@uabc.edu.mx
##### Introducción al Análisis de datos Genómicos y Transcriptómicos de Secuenciación Masiva.
##### Posgrado de Ciencias de la Vida.
##### Cuatrimestre II (abril-agosto,2020)
---
## 1. Terminal de linux
Es un intérprete de comandos u órdenes que permite acceder al sistema operativo sin utilizar la interfaz gráfica, es decir, realizar todo tipo de tareas en formato de texto. La forma de utilizar el sistema de este modo es mediante órdenes.
En la terminal podemos identificar la siguiente información:
* **laulogan**: Indica el usuario conectado a la terminal.
* **@**: significa "en"
* **laulogan-Inspiron-5558**: Indica el nombre de la computadora a la cual estamos conectados.
* **~**: Indica la ruta en la cual nos encontramos, en este caso mi ruta de inicio predeterminada.
* **$**: Indicador para comenzar a escribir nuevas órdenes o comandos.
Éste último también indica nuestro estatus dentro del sistema, es decir, si somos usuarios o superusuarios(#).
## 2. Comandos del sistema
-- **arch**: Muestra la arquitectura de la máquina.
```javascript=
$ arch
```
-- **uname**: Muestra el nombre del sistema operativo.
```javascript=
$ uname
```
-- **top**: Muestra los procesos activos del sistema. Para salir teclear **q** + **ENTER**.
```javascript=
$ sudo top
```
-- **history**: Muestra el historial de comandos introducidos desde el inicio de sesión. Con la opción `-c` limpia el historial de comandos introducidos. **!** + **número de línea**: ejecuta el comando elegido.
```javascript=
$ history
$ history -c
$ !1988
```
-- **date**: Muestra la fecha del sistema.
```javascript=
$ date
```
-- **cal**: Muestra el calendario del sistema.
```javascript=
$ cal
$ cal 2020
$ cal 04 2020
$ cal -A 3 -B 2 05 2020
```
-- **man [comando]**: Muestra el manual de un comando. Tipo paginación. Para salir utilizar la letra **q**.
```javascript=
$ man cal
```
-- **[comando] --help**: Imprime el manual de un comando en la pantalla de la terminal.
```javascript=
$ ls --help
$ mkdir --help
```
-- **exit**: Cerrar la terminal.
```javascript=
$ exit
```
## 3. Comandos para manejo de Archivos y directorios
-- **pwd**: Muestra la ruta actual donde nos encontramos.
```javascript=
$ pwd
```
-- **ls**: lista el directorio en el cual nos encontramos. `-l` lista el directorio en formato lista (uno debajo del otro con opciones); `-la` lista el directorio en formato lista y además muestra todos los archivos ocultos; `-h` muestra los tama;os del fichero en formato legible; `-t` acomoda la lista por fecha.
```javascript=
$ ls
$ ls -l
$ ls -lh
$ ls -lth
$ ls -la
$ ls Documentos/
```
-- **cd [directorio]**: Acceder a directorios. `/` accedemos a la raíz del sistema; `~` accedemos al directorio por defecto **home/usuario**; `..` accedemos al directorio padre, es decir, retrocedemos de nivel.
```javascript=
$ cd /
$ cd ~
$ cd Documentos/
$ cd ..
```
-- **mkdir [filename]**: crea un nuevo directorio.
```javascript=
$ mkdir curso2020
$ mkdir Transcriptoma
$ mkdir Practica Secuencias Analisis
$ mkdir Analisis/Resultados
$ mkdir -p Transcriptoma/{datos/Secuencias,Blast}
$ mkdir RNA Prueba Descargas
```
-- **touch [filename]**: crea archivos vacíos con el nombre especificado.
```javascript=
$ cd RNA
$ touch Mensajero
$ touch mRNA-{1,2,3,A,B,Z}
$ touch mRNA.txt
```
-- **cp [origen] [destino]**: copia archivos de un directorio a otro. Podemos hacer una copia de un archivo y renombrarlo.
```javascript=
$ cp Mensajero ../Prueba/
$ cd ../Prueba/
$ cp Mensajero ../Transcriptoma/datos/Secuencias/
$ ls ../Transcriptoma/Datos/Secuencias/
$ cp Mensajero miRNAs.txt
```
-- **mv [origen] [destino]**: sirve para mover archivos.
```javascript=
$ mv miRNAs.txt ../Analisis
$ mv mRNA-A tRNA.txt
```
-- **rm [file]**: Sirve para borrar archivos. `-rf` borra los archivos de un directorio sin preguntar.
```javascript=
$ rm mRNA-B
$ rm -rf RNA/
```
---
## 4.Comandos para descarga, compresión y descompresión de archivos.
-- **wget**: Descarga documentos de servidores web (http, https, ftp).
```javascript=
$ cd Descargas
$ wget github.com
$ wget https://www.python.org/ftp/python/3.8.1/Python-3.8.1.tgz https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz
$ wget https://www.mirbase.org/ftp/CURRENT/aliases.txt.gz --no-check-certificate
$ wget https://www.mirbase.org/ftp/CURRENT/organisms.txt.gz --no-check-certificate
$ wget https://www.mirbase.org/ftp/CURRENT/hairpin.fa.gz --no-check-certificate
$ wget https://www.mendeley.com/repositories/ubuntu/stable/amd64/mendeleydesktop-latest --no-check-certificate
$ wget https://go.skype.com/skypeforlinux-64.deb --no-check-certificate
```
--**curl**: Descarga documentos de servidores web.
```javascript=
$ curl -Ok ftp://mirbase.org/pub/mirbase/CURRENT/aliases.txt.gz
$ curl -Ok ftp://mirbase.org/pub/mirbase/CURRENT/organisms.txt.gz
$ curl -Ok ftp://mirbase.org/pub/mirbase/CURRENT/hairpin.fa.gz
```
Gzip (GNU zip) es una herramienta de compresión de archivos. Por default el archivo original es reemplazado por el archivo comprimido, adicionandole la terminación **.gz**. El comando gzip sólo comprime archivos, no directorios. Más rápido en comparación con bzip2.
-- **gunzip**: Descomprime archivos.
```javascript=
$ gunzip aliases.txt.gz
$ gunzip organisms.txt.gz hairpin.fa.gz
```
-- **gzip**: Comprime archivos.
```javascript=
$ gzip hairpin.fa
```
bzip2 es una herramienta de compresi+on y descompresión de archivos usando los algoritmos de compresión de Burrows-wheeler y de codificación de Huffman. El porcentaje de compresión generalmente es mejor que el de los compresores basados en algoritmos LZ77/LZ78 (gzip, winzip, compress, etc). Adiciona la terminación **.bz2** al final del archivo comprimido. Tarda menos en descomprimir pero utiliza más memoria. Velocidad media pero mejor calidad de compresión.
-- **bzip2**: Comprime archivos.
```javascript=
$ bzip2 aliases.txt
```
-- **bunzip2**: Descomprime archivos.
```javascript=
$ bunzip2 aliases.txt.bz2
```
tar es un empaquetador de archivos y también tiene la posibilidad de comprimir directorios completos. El programa reúne todos los archivos del directorio seleccionado en un único fichero, en el que los archivos se encadenan unos a otros sin ser modificados.
-- **tar**: Empaqueta varios archivos en uno solo. Opciones `-c` crea un nuevo archivo; `-v` verbose para desplegar una salida; `-z` compresión con gzip; `-j` compresión con bzip2; `-f` selecciona el archivo que queremos comprimir y siempre debe de ir al final de las opciones; `-x` extrae documentos de un archivo.
```javascript=
$ tar -cf One.tar aliases.txt organisms.txt
$ tar -xf One.tar
$ tar -czf One1.tar.gz aliases.txt organisms.txt
$ tar -xzf One1.tar.gz
$ tar -cjf One2.tar.bz2 aliases.txt organisms.txt
$ tar -xjf One2.tar.bz2
```
## 5. Comandos para visualización de archivos
-- **more**: Permite visualizar el contenido de un archivo. Tipo paginación. Sólo avanza hasta el final del archivo. Tecla **ENTER** o **espacio** para avanzar. **q** para salir de visualización. Adicionando una **z** al inicio del comando se pueden visualizar archivos comprimidos.
```javascript=
$ more hairpin.fa
$ zmore hairpin2.fa.gz
```
-- **less**: Permite visualizar el contenido de archivos. Se puede avanzar o retroceder (flechas) durante la visualización. Funciona mejor con archivo pesados.
```javascript=
$ less hairpin.fa
$ zless hairpin2.fa.gz
```
-- **cat**: Imprime el contenido de un archivo en pantalla pero sin ningún tipo de paginación ni posibilidad de modificarlo.
```javascript=
$ cat hairpin.fa
$ zcat hairpin2.fa.gz
```
-- **head**: Imprime las primeras 10 líneas de un archivo.
```javascript=
$ head aliases.txt
$ head -n 20 hairpin.fa
```
-- **tail**: Imprime las últimas 10 líneas de un archivo.
```javascript=
$ tail aliases.txt
$ tail -n 20 hairpin.fa
```
-- **wc**: Imprime el número de líneas, caracteres o palabras que contiene un archivo. Opciones `-l` para líneas, `m` para caracteres y `w` para palabras.
```javascript=
$ wc -l organisms.txt
$ wc -m organisms.txt
$ wc -w organisms.txt
```
-- **cat**: Concatena archivos. **>** direcciona información a un archivo. Sobreescribe información. **>>** direcciona o almacena informacíón después de la ultima línea de un archivo.
```javascript=
$ ls -l organisms.txt
$ ls -l organisms.txt > test1.txt
$ ls -l aliases.txt > test2.txt
$ cat test1.txt test2.txt > list.txt
$ cat test* > list2.txt
$ more list.txt
```
```javascript=
$ head organisms.txt > test3.txt
$ head hairpin.fa > test4.txt
$ cat test3.txt test4.txt >> list.txt
```
:::info
:bulb: **NOTA:** Aquí nos quedamos la clase pasada.
:::
-- **sort**: Reorganiza las líneas en un archivo de texto para que se ordenen numérica y alfabéticamente.
```javascript=
$ cd Descargas/
$ head organisms.txt
$ sort organisms.txt
```
-- **uniq**: Reportar o filtrar líneas repetidas dentro de un archivo. Sólo funciona con líneas repetidas adyacentes. Primero ordenar datos dentro del archivo (sort).
```javascript=
$ cp aliases.txt aliases2.txt
$ head -100 aliases.txt >> aliases2.txt
$ tail -50 aliases.txt >> aliases2.txt
$ head -20 aliases.txt >> aliases2.txt
$ wc -l aliases.txt aliases2.txt
$ sort aliases2.txt | uniq | wc -l
$ sort aliases2.txt | uniq -c | head -20
```
-- **cut**: Corta información de un archivo. Siempre se debe especificar una opción. `-f` (campo) más común.
```javascript=
$ cut -f 3 organisms.txt
$ cut -f 1-3 organisms.txt
$ cut -f 1,3,5 organisms.txt
```
-- **clear**: Limpia el texto de la pantalla.
```javascript=
$ clear
```
-- **grep [text] [filename]**: Busca texto dentro de un archivo. `-c` indica el número de líneas en las que aparece el texto indicado. `-A` busca el texto indicado más las 10 líneas posteriores. `-B` busca el texto indicado más los 10 líneas anteriores a esa palabra. `-l` indica si el texto indicado se encuentra dentro de ese archivo.
```javascript=
$ grep “Ciona” organisms.txt
$ grep -c “Ciona” organisms.txt
$ grep “Helianthus” organisms.txt
$ grep -c “Helianthus” organisms.txt
$ grep -A 10 “Helianthus” organisms.txt
$ grep -B 10 “Helianthus” organisms.txt
$ grep -l “Helianthus” organisms.txt
$ grep -l “Bacter” organisms.txt
$ grep -c “^>” hairpin.fa
$ grep -c “^>” hairpin.fa
```
-- **|** : Se conoce como pipe. Permite usar dos o más comandos, de manera que la salida de un comando sirve como entrada para el siguiente. Unidireccional.
```javascript=
$ ls -l | head -n 4
$ sort hairpin.fa | wc -l
$ head organisms.txt | sort
$ sort organisms.txt | head
$ sort -r organisms.txt | head -n 20
$ sort -k3 organisms.txt | less
$ cut -f 1 organisms.txt | head
$ cut -f 1,3 organisms.txt | sort | more
$ grep "mmu" aliases.txt | cut -f2 | wc -l
$ grep "mmu" aliases.txt | cut -f2 | tail
$ grep "mmu" aliases.txt | cut -f2 | grep "p" | more
$ grep "mmu" aliases.txt | cut -f2 | grep "p" | head
$ grep "mmu" aliases.txt | cut -f2 | grep "p" | sort -r | uniq -u | head -n 200 > sample_alias.txt
```
-- **whereis**: Muestra la ruta en donde se encuentra el archivo binario y la ruta hacia el manual del comando determinado.
```javascript=
$ whereis ls
$ whereis grep
$ whereis blastx
```
-- **which**: Muestra la ruta al archivo binario de un comando determinado.
```javascript=
$ which mkdir
$ which head
$ which blastx
```
-- **whatis**: Muestra la función del comando determinado.
```javascript=
$ whatis ls
$ whatis mkdir
$ whatis cut
```
## 6. Enlaces simbólicos
Los enlaces simbólicos son enlaces entre archivos y directorios cuyo objetivo principal es no duplicar información y saturar el disco duro. Los hard link son creados generalmente por el sistema.
-- **ln -s [Origen] [Destino]** : Link (enlace) simbólico indica un acceso directo a una carpeta o archivo que se encuentra en un lugar distinto dentro de la estructura de directorios. Si el archivo enlazado es renombrado, movido o borrado se rompe el acceso.
```javascript=
$ cd Descargas
$ pwd
$ ln -s /home/laulogan/Documentos/curso2020/Descargas/hairpin.fa ../Secuencias/
$ ls -l ../Secuencias
```
```javascript=
$ cd ../Secuencias
$ ln -s /home/laulogan/Documentos/curso2020/Descargas/organisms.txt ./
$ ls -l
```
```javascript=
$ ln -s /home/laulogan/Documentos/curso2020/RNA/ ./
$ ls -l
$ ls RNA
```
## 7. Editor de texto
**GNU nano** es un editor de texto que nos permite modificar o crear archivos de texto dentro de la terminal de linux.
-- **nano (Filename)**: `Ctrl + o` para guardar y `Ctrl + x` para salir.
```javascript=
$ nano prueba_curso.txt
```
* Crear link simbólico a archivo `aliases2.txt` que se encuentra dentro del directorio `Descargas` y modificar el nombre de las columnas.
```javascript=
$ nano aliases2.txt
```
# Conexión por VPN a red de CICESE
Para conectarse a la red de CICESE a través de VPN deben seguir las instrucciones siguientes:
* Tener a la mano:
- [x] Usuario de cuenta de correo CICESE
- [x] Contraseña original
**Paso 1:** Instalar vpn
```javascript=
$ sudo apt-get install vpnc
```
**Paso 2:** Acceder a VPN de CICESE
```javascript=
$ sudo vpnc-connect
```
**Paso 3:** Colocar la información requerida.
* IPSeq gateway adress: **158.97.255.193**
* IPSeq ID: **VPNCICESE**
* IPSeq secret: **c1c3s3VPN**
* Username: **<usuario>**
* Password: **<contraseña_original>**
:::info
:bulb: **NOTA:** La intalación de la VPN en la terminal se realiza una sola vez. Para conectarse posteriormente, se deberá comenzar a partir del paso 2.
:::
Si la conexión se realizó con éxito deberan visualizar en su terminal el siguiente mensaje:
# Acceso a Servidor/Cluster [OMICA](http://omica.cicese.mx/docs/index.html)
Cada estudiante deberá acceder al cluster OMICA con una cuenta del curso.
```javascript=
$ ssh curso##@omica
```
Substituir el doble hash (##) por el número de cuenta asignado (ver tabla 1).
:::success
:key: **Password:** Curso-tmp##
:::
* **Tabla 1.** Asignación de cuentas en OMICA
| Estudiante | Cuenta | Estudiante | Cuenta |
| ---------- | ------ | ---------- | ------ |
| Sebastián | curso02 | Alan | curso11 |
| Alberto | curso03 | Brenda | curso12 |
| Erick | curso04 | Victor | curso13 |
| Willian | curso05 | José Luis | curso14 |
| Eugenio | curso06 | Lizt | curso15 |
| Luz | curso07 | Karla | curso16 |
| Jesús A. | curso08 | Luis Adrian| curso17 |
| Antonio | curso09 | Estefany | curso18 |
| Melissa | curso10 |
## 1. Comandos básicos
**sbatch [Filename]**: Sirve para enviar una tarea a ejecución a través de SLURM.
**squeue**: Sirve para revisar los trabajos en ejecución o que se encuentran en la cola de tareas.
**scancel [jobID]**: Sirve para cancelar una tarea.
**top**: Sirve para visualizar los procesos que se estan ejecutando.
**sinfo**: Muestra información sobre nodos de cómputo y particiones
## 2. Copiar archivos OMICA/PC y viceversa.
1. Copiar archivos entre directorios dentro del cluster
```javascript=
$ cd curso2020
$ cp /LUSTRE/bioinformatica_data/genomica_funcional/Laura/Blastx.slrm ./
```
```javascript=
$ cp -r /LUSTRE/bioinformatica_data/genomica_funcional/Laura/Curso_transcriptomica/Blast ./
$ ls
```
2. Copiar archivos de un servidor a local (OMICA a Mi PC).
Paso 1. Abrir una terminal nueva.
Paso 2. Entrar a la carpeta donde queremos colocar el archivo
```javascript=
$ cd Documentos/curso2020
$ mkdir OMICA
$ cd OMICA
$ scp curso01@omica:/home/curso01/curso2020/Transcriptomics/Blastx.slrm ./OMICA/
$ scp -r curso01@omica:/home/curso01/curso2020/Transcriptomics/Blastx ./OMICA/
```
3. Copiar archivos de local a servidor (Mi PC a OMICA).
Paso 1. Abrir una terminal nueva y colocar la ruta hacia el archivo que queremos copiar + la ruta a la carpeta en la que queremos colocar la información.
```javascript=
$ scp ./Documentos/curso2020/Descargas/aliases.txt curso01@omica:/home/curso01/curso2020/
$ scp -r ./Documentos/curso2020/Descargas/ curso01@omica:/home/curso01/curso2020/
```
###### tags: `Clase NGS`
Sign in with Wallet
Connect another wallet