Sistemas Informáticos

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Administración de Sistemas Operativos Multiusuario ======
En este bloque se centra en la administración de un sistema operativo multiusuario GNU/Linux. Existen diferentes distribuciones de Linux, pero todas ellas se basan en el mismo núcleo (Kernel de Linux) y las operaciones de administración serán casi siempre las mismas.

===== Sistema Operativo GNU/Linux =====
{{ :unidad4:gnu-linux.png?200|}}
GNU/Linux es un sistema operativo de libre distribución, basado en UNIX, y es mutiplataforma, multiusuario y multitarea. Es el resultado de 2 proyectos: 
  * **Proyecto GNU**: Es el proyecto inicial, nunca se llegó a construir el kernel, pero si gran parte de sus herramientas (compiladores, escritorio, etc).
  * **Proyecto Linux**: Es el núcleo (kernel) del ssoo, creado por Linus Torvalds.

Aunque normalmente nos referimos a Linux como el sistema operativo, Linux es solamente el kernel del mismo.

GNU/Linux se distribuye como //software libre// bajo la licencia //GPL// (Licencia pública general de GNU). Esto hace que todo su código fuente puede ser utilizado, modificado y redistribuido libremente por cualquiera.


==== Distribuciones ====
GNU/Linux se ofrece en formato de distribuciones. Una distribución es un conjunto de programas, entornos de escritorio y ficheros preparados para su instalación. Como es software libre, las distribuciones se pueden descargar normalmente desde el sitio web oficial de la distribución. 

Esto hace que existan //diferentes linux//, aunque todos tienen el mismo nucleo en común. 

^Nombre distribución^Descripción^
|Debian|Distribución GNU enfocada al desarrollo, apoyada por una comunidad de usuarios y desarrolladores, utiliza exclusivamente repositorios de software libre|
|Suse|Distribución fácil de instalar y administrar|
|Red Hat|Una de las distribuciones Linux de proposito general más famosas|
|Fedora|Distribución comunitaria de proposito general estable, basada en Red Hat|
|Ubuntu|Distribución basada en Debian enfocada en facilitar su uso|
|Mint|Distribución basa en Ubuntu/Debian|
|Kali|Distribución basada en Debian enfocada en el hacking|
|Android|Sistema operativo para sistemas portables, con nucleo Linux|

=== Kernel de Linux ===
Es el núcleo de sistema operativo, encargado de la gestión de procesos, de memoria, de archivos y de la entrada y salida de datos.

==== Entornos de Escritorio ====
Linux es un sistema que se puede manejar desde un terminal de comandos o desde un entorno de escritorio.
En linux, el entorno de escritorio es un programa más y por eso tenemos la opción de instalar varios y poder utilizar el que queramos. Cada distribución incluye uno o varios. Algunos de los más comunes son:

{{ :unidad4:escritorios1.png?550 |}}

 ==== Usuarios y grupos de Linux ====
  * **Usuarios comunes**: Son los usuarios corrientes del sistema. Tienen acceso restringido a determinados ficheros y recursos del sistema, así como a los archivos del resto de usuarios. Tienen acceso a un directorio de trabajo llamado //HOME//. Se encuentra en /home/nombreUsuario

  * **Usuario root**: También llamado //superusuario//, es el usuario administrador del sistema, y puede hacerlo todo. Por tanto, para mantener la seguridad, se debe limitar su uso a tareas unicamente de administración.

  * **Usuarios de sistema**: Son usuarios utilizados por el sistema operativo para lanzar procesos con unos determinados permisos. Ninguna persona puede entrar en linux como un usuario de sistema.

Además cada vez que creamos un usuario, creamos también un **grupo de trabajo** con el mismo nombre que el usuario. Podemos asignar usuarios a otros grupos.

==== Árbol de directorios ====

Linux utiliza igual que otros sistemas operativos, ficheros y directorios para organizar la información. Los directorios forman una estructura en modo de árbol, cuyo origen se llama directorio raíz. Este directorio raíz se muestra en Linux con el carácter **'/'**. 

En linux solo existe un árbol de directorios, y no uno por disco o partición, como en Windows. Si se añade un nuevo disco al sistema, debe //montarse// en algún directorio del árbol.

{{ :unidad4:unix-directory.gif?600 |}}


La finalidad de los directorios principales del sistema es:
^^^
|/bin|Programas binarios esenciales (cp, mv, ls, rm, etcétera)|
|/sbin|Binarios de administración del sistema operativo, requiere permisos de superusuario|
|/boot|Ficheros utilizados durante el arranque del sistema|
|/dev|Dispositivos (devices) esenciales, discos duros, terminales, sonido, video, lectores dvd/cd|
|/etc|Ficheros de configuración utilizados en todo el sistema y que son específicos del ordenador|
|/home|Contiene los directorios de trabajo de cada usuario (/home/fernando, /home/usuario2)|
|/lib|Bibliotecas compartidas esenciales para los binarios (/bin) y los binarios del sistema (/sbin)|
|/media|Puntos de montaje de dispositivos de almacenamiento (pen drives, cdroms, etc)|
|/root|Directorio de inicio del usuario root (superusuario)|
|/tmp|Ficheros temporales|
|/usr|(Unix System Resources) Contiene información de solo lectura que se comparte por otros recursos del sistema|
|/var|Ficheros variables, como logs, bases de datos, buzones de correo, etc|
|/srv|(served by your system) Se usa para almacenar información de servidores, ftp, http, etc|
|/opt|Almacena software opciones, obtenido fuera del repositorio apt|

=== Rutas absolutas y relativas ===
Para referenciar un archivo o directorio se utiliza una cadena llamada ruta: es la descripción de los directorios que hay que recorrer para llegar hasta él.

Existen dos tipos de rutas:

  * **Ruta absoluta**: Es la ruta completa desde el directorio raiz hasta el archivo o directorio. Empieza siempre en el directorio raiz( / ): /home/fernando/Escritorio/fichero.txt

  * **Ruta relativa**: Es la ruta que parte del directorio en el que nos encontramos, hasta el archivo o directorio que buscamos. __No empieza en el raiz__( / ). Si me encuentro en el directorio /home/fernando la ruta sería Escritorio/fichero.txt

Además la ruta de mi directorio HOME (p.e. /home/fernando) se puede representar por el caracter ( **~** ).

==== Ficheros y permisos ====
=== Tipos ===
En Linux todo se maneja desde ficheros: dispositivos de almacenamiento, impresoras, periféricos, directorios, puertos, etc. **Todo se representa en linux mediante un fichero**. Existen generalmente 4 tipos:

  * **Ficheros regulares**: Pueden ser de texto plano, de datos binarios, ejecutables de texto (shell scripts) o ejecutables binarios.
  * **Directorios**: Ficheros que contienen una lista de otros ficheros y punteros a esos mismos. El concepto es diferente a los directorios de Windows.
  * **Enlaces**: Enlaces a otros ficheros, similar al concepto de acceso directo en sistemas Microsoft.
  * **Ficheros especiales**: suelen representar dispositivos hardware. Están ubicados en el directorio /dev y hay dos tipos: los que funcionan por carácter y los que funcionan por bloques:
    * Carácter: terminales, impresoras puertos serie/paralelo, etc. Aceptan y producen cadenas de caracteres.
    * Bloques: discos duros, memorias flash, cdrom o dvd, acceden a bloques completo de información.

  * Los **ficheros ocultos** son cualquier tipo de fichero cuyo nombre empiece por el caracter ( **.** ).

Los nombre de los ficheros son //**case-sensitive**//: file1 y File1 son distintos ficheros.

=== Permisos ===
Cuando ejecutamos en un terminal el comando ''ls -l'' mostramos las propiedades de un fichero. Los primeros 10 caracteres representan el tipo y los permisos del fichero:
{{ :unidad4:permisos-lsl.png?400 |}}

El **primer caracter** representa el tipo del fichero y puede ser:

  * ''-'' : fichero regular
  * ''d'' : directorio
  * ''l'' : enlace simbólico
  * ''c'' : fichero de dispositivo de caracter
  * ''b'' : fichero de dispositivo de bloque
  * ''s'' : fichero de socket local
  * ''p'' : fichero de tubería

Los siguientes 9 caracteres representan los permisos que tienen los diferentes usuarios sobre ese fichero. 
{{ :unidad4:permisos-file.png?300 |}}
Puede contener 4 diferentes caracteres:
  * ''-'': Sin permisos
  * ''r'': Permisos de lectura
  * ''w'': Permisos de escritura
  * ''x'': Permisos de ejecución

 Y están organizados en 3 grupos de 3 caracteres (9 en total):

  * Primer grupo de 3 caracteres: representa los permisos del usuario propietario del fichero
  * El segundo grupo de 3 caracteres: representa los permisos de usuarios del grupo del fichero
  * El tercer grupo de 3 caracteres: representa los permisos del resto de usuario

==== Ficheros de configuración ====
Aunque existen ficheros de configuración para cualquier aplicación, vamos a ver algunos de los principales fichero de configuración del sistema:

  * **/etc/passwd** Contiene una lista con todos los usuarios del sistema. Cada linea contiene diferentes campos separados por el caracter ( : ):
{{ :unidad4:passwd.png?600 |}}
{{ :unidad4:etc-passwd.png?600 |}}

  * **/etc/group**: En este fichero se guardan los datos de los grupos existentes en el sistema, separados por el caracter ( : ) -> Nombre del grupo:campo con caracter x que ya no se utiliza:GID o id del grupo:lista de usuarios del grupo separados por comas

  * **/etc/shadow**: Este fichero almacena la contraseña de cada usuario y parámetros asociados con la validez de dichas contraseñas. Los usuarios comunes no tienen permisos sobre este fichero.

  * **/etc/init.d/rc.local**: Es un fichero ejecutable (shell script) de Ubuntu Linux, que se ejecuta cada vez que arranca el sistema. En él podemos indicar algunas instrucciones que queremos que se ejecuten al inicio.




===== Shell de Linux =====
La shell es un programa que recoge los comandos introducidos por el usuario, los interpreta, y si son correctos los ejecuta.

Abrimos un interprete shell en nuestro sistema desde el menú aplicaciones → terminal.

{{ :unidad4:bourneshell.png?600 |}}

El shell tiene un encabezado de texto "**ssii@ssii:~$**" donde se indica el nombre del usuario (ssii), el nombre del equipo (ssii), la ruta en la que estamos (**~** -> /home/ssii), y carácter que nos indica un usuario normal ($) o superusuario (#).

Este encabezado se conoce como **prompt**.

Existen diferentes tipos de shell, aunque actualmente se utiliza el shell **bash** (bourne again shell). En nuestro directorio HOME se guarda un historial de los comandos tecleados en el fichero ".bash_history". 

=== Ejecutar comandos en segundo plano ===

Para ejecutar un comando y que mientras se está ejecutando no bloquee el shell, usamos el caracter //ampersand// **&** al final del comando:
<code bash>
#Abro el fichero1 con el editor gedit en segundo plano
fer@debian:~$ gedit fichero1 &

#Abro firefox en segundo plano desde el terminal
fer@debian:~$ firefox &
</code>

Si un proceso bloque nuestro terminal podemos terminarlo con **CTRL + c**
==== Comandos de ayuda ====
<code bash>
#Mostrar el manual del un comando (comando mkdir en este caso)
fer@debian:~$ man mkdir

#Muestra un resumen de ayuda del comando mkdir
fer@debian:~$ mkdir --help

#Indica que hace un comando
fer@debian:~$ whatis mkdir

#Indica donde se encuentra el binario del comando
fer@debian:~$ whereis mkdir

</code>

====Comandos de ficheros/directorios====
=== pwd===
Muestra la ruta en la que estoy actualmente
<code bash>
fer@debian:~/Downloads$ pwd
/home/fernando/Downloads
</code>
=== cd ===
Cambiar de directorio. Puedo indicar una ruta relativa o una ruta absoluta
En todo directorio hay dos directorios ocultos:
  * ''.'' : representa el directorio actual
  * ''..'' : representa el directorio padre del directorio actual

<code bash>
#Voy al directorio /etc (ruta absoluta)
fer@debian:~$ cd /etc

#Voy al directorio /home/fernando (ruta absoluta)
fer@debian:~$ cd /home/fernando

#Voy al directorio pruebas desde el directorio /home (ruta relativa)
fer@debian:/home$ cd fernando/Escritorio/pruebas

#Voy al directorio Home del usuario
fer@debian:~$ cd ~

#Voy al directorio Home del usuario (igual que el anterior)
fer@debian:~$ cd

#Voy al directorio padre del actual
fer@debian:~$ cd ..

#Voy al directorio Descargas situado en mi directorio padre (ruta relativa)
fer@debian:~/Escritorio$
fer@debian:~$ cd ../Descargas
</code>

=== ls ===
Lista el contenido de un directorio, o tantos como le indique
<code bash>
fer@debian:~$ ls
fichero.txt dmesg.txt services bbdd.sql

#ls con la opción -a muestra también los ficheros ocultos
fer@debian:~$ ls -a
. .. .bashrc .bash_history .bash_profile fichero.txt dmesg.txt services bbdd.sql

#Lista el contenido de un directorio concreto
fer@debian:~$ ls /bin

#ls con la opción -l lista los ficheros y sus propiedades
fer@debian:~$ ls -l
total 17296
-rw-r--r-- 1 fer fer 17584442 Sep 17 00:03 allfiles.txt
-rw-r--r-- 1 fer fer 96650 Sep 17 00:03 dmesg.txt
-rw-r--r-- 1 fer fer 19558 Sep 17 00:04 services
drwxr-xr-x 2 fer fer 4096 Sep 17 00:04 stuff
-rw-r--r-- 1 fer fer 0 Sep 17 00:04 hummer.txt

# La 1ª columna es el tipo de fichero/permisos
# la 2ª el usuario propietario del fichero
# la 3ª el grupo propietario del fichero
# la 4ª el tamaño, después la fecha/hora y finalmente el nombre
</code>

=== mkdir ===
Crea directorios
<code bash>
#Creo dos directorios en el directorio actual
fer@debian:~$ mkdir directorio1 directorio2

#Creo un directorio en la ruta absoluta /home/fernando/Escritorio/directorio2
fer@debian:~$ mkdir /home/fernando/Escritorio/directorio2

#Creo un directorio, y sus directorios padre si no existen
fer@debian:~$ mkdir -p directorio1/directorio11/directorio111
</code>

=== rmdir ===
Elimina un directorio **vacío**
<code bash>
#Borro el directorio vacio directorio11
fer@debian:~$ rmdir directorio1/directorio11

#Borro el directorio vacio directorio1
fer@debian:~$ rmdir directorio1

#Borro todos los directorios si están vacíos
fer@debian:~$ rmdir -p directorio1/directorio11/directorio111
</code>

=== touch ===
Permite crear un fichero vacío
<code bash>
fer@debian:~$ touch fichero1

#Crear un fichero vacío en directorio1/directorio11
fer@debian:~$ touch directorio1/directorio11/fichero-vacio
</code>

=== rm ===
Elimina para siempre. Estos fichero no van a la papelera ni nada similar
<code bash>
#Elimino un fichero
fer@debian:~$ rm fichero1

#Elimino todos los fichero del directorio1 que empiecen por f
fer@debian:~$ rm directorio1/f*

#Elimino el directorio1 con todo su contenido (tanto ficheros como subdirectorios)
fer@debian:~$ rm -rf directorio1
</code>

=== cp===
Copia ficheros o directorio desde ruta origen a ruta destino
<code bash>
#Copiar un unico fichero cambiándole el nombre
fer@debian:~$ cp file42 file42.copia

#Copiar un unico fichero a directorio1
fer@debian:~$ cp file42 directorio1

#Copiar un unico fichero a directorio1 cambiandole el nombre
fer@debian:~$ cp file42 directorio1/fichero_copia

#Copio un directorio y su contenido a directorio2
fer@debian:~$ cp -r directorio1 directorio2

#Copio varios fichero a directorio1
fer@debian:~$ cp fichero1 fichero2 directorio1

#Copio los fichero que empiezan por f de directorio1 al directorio actual
fer@debian:~$ cp directorio1/f* .

</code>
=== mv===
Mueve ficheros de una ruta a otra (también puede renombrar)
<code bash>
# Muevo el fichero1 de ./fichero1 a ./fichero2 (renombra)
fer@debian:~$ mv fichero1 fichero2
fer@debian:~$ mv ./fichero1 ./fichero2

#Muevo el directorio1 de ./directorio1 a ./directorio2 (renombra si directorio2 no existe)
fer@debian:~$ mv directorio1 directorio2
fer@debian:~$ mv ./directorio1 ./directorio2

#Muevo el directorio1 a directorio2 (directorio2 debe existir, sino renombra)
fer@debian:~$ mv directorio1 directorio2
fer@debian:~$ mv ./directorio1 ./directorio2

#Muevo todos los ficheros del directorio actual a directorio2
fer@debian:~$ mv * directorio2
fer@debian:~$ mv ./* directorio2

#Muevo todos los ficheros que terminan por f que hay en directorio1 a directorio2/directorio22
fer@debian:~$ mv directorio1/f* directorio2/directorio22
</code>

=== head===
Muestra las diez primeras líneas de un fichero. También puede mostrar las **n** primeras lineas de un fichero
<code bash>
#Muestro las 10 primeras lineas del fichero /etc/passwd
fer@debian:~$ head /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
lp:x:7:7:lp:/var/spool/lpd:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh

#Muestro las 3 primeras lineas del fichero /etc/passwd
fer@debian:~$ head -3 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh

</code>
=== tail===
Igual que head, pero mostrando las 10 últimas lineas, o **n** últimas lineas
<code bash>
#Muestro las 3 últimas lineas
fer@debian:~$ tail -3 /etc/services
vboxd 20012/udp
binkp 24554/tcp 
asp 27374/tcp 
</code>
=== cat===
Es una de las herramientas más universales del entorno de comandos. Tiene diferentes usos
<code bash>
#Mostrar el contenido de un fichero
fer@debian:~$ cat /etc/resolv.conf
domain linux-training.be
search linux-training.be
nameserver 192.168.1.42

#Concatenas varios ficheros : muestra los 3 ficheros seguidos
fer@debian:~$ cat fichero1 fichero2 fichero3

#Crear un fichero a partir de lineas introducidas por teclado
fer@debian:~$ cat > fichero.txt
introduzco una linea por teclado  #pulso enter
introduzco otra linea  #pulso enter
#Para terminar pulsamos CTRL + D 

#Muestro el contenido del fichero creado
fer@debian:~$ cat fichero.txt
introduzco una linea por teclado
introduzco otra linea

#También me permite añadir cadenas desde teclado a un fichero
fer@debian:~$ cat >> fichero.txt
introduzco una mas  #pulso enter
introduzo la ultima linea  #pulso enter
#Pulso CTRL + d para terminar

#Muestro el contenido del fichero al que he añadido lineas
fer@debian:~$ cat fichero.txt
introduzco una linea por teclado
introduzco otra linea
introduzco una mas
introduzo la ultima linea

</code>
=== more ===
Muestra el contenido de un fichero, y si no entra en la dimensión del terminal, permite mostrarlo página a página, o línea a línea. Pulsando "intro" avanzamos de linea, pulsando "espacio" avanzamos una página, y con la "q", terminamos el comando.

<code bash>
fer@debian:~$ more /etc/passwd
</code>

=== file ===
Me indica el tipo de fichero. Las extensiones en linux son solamente parte del nombre.

<code bash>
fer@debian:~$ file pic33.png
pic33.png: PNG image data, 3840 x 1200, 8-bit/color RGBA, non-interlaced

fer@debian:~$ file /etc/passwd
/etc/passwd: ASCII text

fer@debian:~$ file HelloWorld.c
HelloWorld.c: ASCII C program text

</code>

=== find ===
Busca ficheros dentro del sistema de archivos
<code bash>
#Busca todos los ficheros en /etc 
fer@debian:~$ find /etc

#Busca todos los ficheros del sistema
fer@debian:~$ find / 

#Busca todos los fichero que terminan por .conf en el directorio actual y subdirectorios
fer@debian:~$ find . -name "*.conf"

#Busca los ficheros de tipo regular que terminan en .conf
fer@debian:~$ find . -type f -name "*.conf"

#Busca los ficheros de tipo directorio que terminan en .bak en el directorio /data
fer@debian:~$ find /data -type d -name "*.bak"
</code>
==== Generación dinámica de nombres ====

=== Caracter * (asterisco) ===
A la hora de indicar nombres de ficheros, el asterisco sustituye cualquier combinación de caracteres, incluso ninguno

<code bash>
fer@debian:~$ ls
file1 file2 file3 File4 File55 FileA fileab Fileab FileAB fileabc

# listar ficheros que comienza por File
fer@debian:~$ ls File*
File4 File55 FileA Fileab FileAB

# listar ficheros que comienza por file
fer@debian:~$ ls file*
file1 file2 file3 fileab fileabc

# listar ficheros que terminan con ile55
fer@debian:~$ ls *ile55
File55

# comienzan por F y terminan ile55
fer@debian:~$ ls F*ile55
File55
# comienzan por F y terminan por 55
fer@debian:~$ ls F*55
File55
</code>

=== Caracter ? ===
El caracter ? sustituye a un único caracter en los nombres de los ficheros

<code bash>
fer@debian:~$ ls
file1 file2 file3 File4 File55 FileA fileab Fileab FileAB fileabc

# Comienzan por File y les sigue un único caracter
fer@debian:~$ ls File?
File4 FileA

# Comienzan por Fil, después un caracter y terminan en 4
fer@debian:~$ ls Fil?4
File4

# Comienzan por Fil, y después dos caracteres
fer@debian:~$ ls Fil??
File4 FileA

# Ficheros cuyo nombre tiene 5 caracteres exactos
fer@debian:~$ ls ?????
file1 file2 file3 File4 FileA
</code>

=== Corchetes [ ] ===
Los corchetes incluyen caracteres, e indican que un caracter del nombre de un fichero puede ser cualquier de los que hay entre corchetes. También se pueden indicar rangos de caracteres o cifras:

<code bash>
fer@debian:~$ ls
file1 file2 file3 File4 File55 FileA fileab Fileab FileAB fileabc

# Comienzan por File y terminan en 5 ó A
fer@debian:~$ ls File[5A]
FileA

# Comienzan por File, después un '5' ó una 'A' y después un '5' ó una 'b'
fer@debian:~$ ls File[A5][5b]
File55

# Comienzan por File, después un '5' ó una 'a' y después un '5' ó una 'b'
fer@debian:~$ ls File[a5][5b]
File55 Fileab

#Ficheros que empiecen por "file" sigan con una letra minúscula, y después cualquier caracter
fer@debian:~$ ls file[a-z]*
fileab fileab2 fileabc

# Comienzan por file y después un caracter del rango 0-9
fer@debian:~$ ls file[0-9]
file1 file2 file3

# Comienzan por file, depués una letras minúscula, después otra minúscula, 
# después una cifra, y terminan con cualquier combinación
fer@debian:~$ ls file[a-z][a-z][0-9]*
fileab2

# Tambien puedo indicar el caracter ! para negar
# Ficheros que empiezan por "file", después no contienen un 5, 
# y después cualquier caracter
fer@debian:~$ ls file[!5]*
file1 file2 file3 fileab fileabc
</code>
==== Filtros y redirección====

Los filtros son comandos que limitan (filtran) la salida de otros comandos. Se suelen utilizar con el caracter ( | ) (tuberia, ALT GR + 1). Algunos también se pueden usar directamente sin tuberías.

=== grep ===
Es el filtro más famoso se usa para buscar texto en la salida de un comando. 

<code bash>
fer@debian:~$ cat tennis.txt
Amelie Mauresmo, Fra
Kim Clijsters, BEL
Justine Henin, Bel
Serena Williams, usa
Venus Williams, USA

fer@debian:~$ cat tennis.txt | grep Williams
Serena Williams, usa
Venus Williams, USA

#Se puede hacer esto sin el cat
fer@debian:~$ grep Williams tennis.txt
Serena Williams, usa
Venus Williams, USA

</code>

=== cut ===
El filtro cut puede seleccionar columnas de ficheros de texto, dependiendo del carácter delimitador.
  * Con la opción ''-d'' le indico el caracter separador: ''-d":"''
  * Con la opción ''-f'' le indico las filas a cortar: ''-f1,5'' (filas 1 y 5)
<code bash>
#Contenido del fichero /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
. . .

#Corto las columnas 1 y 3, separadas por : , y muestro solo las 4 últimas lineas del fichero
fer@debian:~$ cut -d: -f1,3 /etc/passwd | tail -4
postgres:120
fer2:1001
mongodb:121
vboxadd:999

#Busco la linea de mi usuario en el fichero passwd y corto la fila del nombre
fer@debian:~$ cat /etc/passwd | grep fer | cut -d":" -f1
fer


fer@debian:~$ cat tennis.txt
Amelie Mauresmo, Fra
Kim Clijsters, BEL
Justine Henin, Bel
Serena Williams, usa
Venus Williams, USA

#Cuando indico el espacio como caracter separador debo entrecomillarlo
fer@debian:~$ cut -d" " -f1 tennis.txt
Amelie
Kim
Justine
Serena
Venus
</code>

=== tr ===
Se puede sustituir caracteres con tr. Nos sirve para poder organizar por columnas, antes de aplicar el comando ''cut''.

<code bash>
#Sustituyo todos los caracteres e por E.

fer@debian:~$ cat tennis.txt | tr 'e' 'E'
AmEliE MaurEsmo, Fra
Kim ClijstErs, BEL
JustinE HEnin, BEl
SErEna Williams, usa
VEnus Williams, USA

#Cambiamos todas las letras a mayúsculas definiendo 2 rangos.
fer@debian:~$ cat tennis.txt | tr 'a-z' 'A-Z'
AMELIE MAURESMO, FRA
KIM CLIJSTERS, BEL
JUSTINE HENIN, BEL
SERENA WILLIAMS, USA
VENUS WILLIAMS, USA

# tr -s sustituye todas las ocurrencias de un carácter en una sola.
fer@debian:~$ cat spaces.txt
one   two    three
four   five    six
fer@debian:~$ cat spaces.txt | tr -s ' '
one two three
four five six

# Sustituyo todas las apariciones de ' ' por una sola y cambio el caracter ' ' por ':'
fer@debian:~$ cat spaces.txt
one   two    three
four   five    six
fer@debian:~$ cat spaces.txt | tr -s ' ' :
one:two:three
four:five:six


#También se puede usar tr -d para borrar caracteres.
fer@debian:~$ cat tennis.txt | tr -d e
Amli Maursmo, Fra
Kim Clijstrs, BEL
Justin Hnin, Bl
Srna Williams, usa
Vnus Williams, USA
</code>

=== wc ===
Cuenta las palabras, lineas o caracteres

<code bash>
#Cuenta las lineas del fichero tennis.txt
fer@debian:~$ cat tennis.txt | wc -l

#Cuenta las palabras del fichero
fer@debian:~$ cat tennis.txt | wc -w

#Cuenta las lineas que muestra el comando ls -l
fer@debian:~$ ls -l | wc -l
</code>

=== sort ===
Con sort ordenamos por defecto en orden alfabético
<code bash>
fer@debian:~$ cat music.txt
Queen
Brel
Led Zeppelin
Abba

fer@debian:~$ sort music.txt
Abba
Brel
Led Zeppelin
Queen

</code>

=== Ejemplos combinados ===
<code bash>
#¿Cuántos usuarios están logueados en el sistema?
fer@debian:~$ who
root tty1 Jul 25 10:50
fer pts/0 Jul 25 09:29 
Usuario pts/1 Jul 25 12:26 
fer pts/2 Jul 25 12:26 
fer@debian:~$ who | wc -l
4

#Muestra una lista ordenada de los usuarios logueados. 
fer@debian:~$ who | cut -d' ' -f1 | sort
Usuario
fer
fer
root

#Muestra una lista de todos los usuarios que usan el shell bash 
#Lineas que contienen la cadena "bash"
fer@debian:~$ grep bash /etc/passwd
root:x:0:0:root:/root:/bin/bash
fer:x:1000:1000:paul,,,:/home/paul:/bin/bash
postgres:x:1001:1001::/home/serena:/bin/bash

#Corto y me quedo solo con la 1ª columna: nombres usuario
fer@debian:~$ grep bash /etc/passwd | cut -d: -f1
root
fer
postgres
</code>
=== Caracteres de redirección ===
Son los caracteres >, <nowiki>>></nowiki>, <. Se usan para redirigir la salida o entrada de datos hacia un comando.

<code bash>
#Crear un fichero con la salida del comando ls -l
#Si el fichero ya existe, se sobrescribe
fer@debian:~$ ls -l > fichero.txt

#Añadir texto al fichero anterior a partir de la salida del comando who
#Si el fichero ya existe, se añade sin borrar el contenido
fer@debian:~$ who >> fichero.txt

#Buscar la palabra root a partir de los datos de un fichero
fer@debian:~$ grep root < fichero.txt

#Crear un fichero que contenga a los ficheros /etc/passwd y /etc/group
fer@debian:~$ cat /etc/passwd /etc/group > fichero-conjunto

#Copiar un fichero
fer@debian:~$ cat /etc/passwd > passwd-copia
</code>



==== Variables de entorno ====
Una variable de entorno es un nombre que representa una cadena de caracteres

^Variable^Descripción^
|HOME|Ruta directorio personal|
|HOSTNAME| Nombre de la máquina|
|PATH|Lista de directorios donde buscar los programas ejecutables|
|PS1|Prompt|
|SHELL|Intérprete de comandos por defecto|
|USER|Nombre del usuario|

<code bash>
#Mostrar variables de entorno
fer@debian:~$ env

#Mostrar el contenido de una variable (PATH en este caso)
fer@debian:~$ echo $PATH

#Modificar la variable PATH, añadiendo una ruta
fer@debian:~$ PATH=$PATH:/home/fer/programas
</code>

==== Procesos ====
<code bash>
# Mostrar los procesos que se están ejecutando 
fer@debian:~$ top

# Mostrar la lista de procesos del usuario 
fer@debian:~$ ps 	

# Todos los procesos de cualquier usuario
fer@debian:~$ ps -e           

# Mostrar los procesos en forma de árbol
fer@debian:~$ pstree          

# Mostrar la lista de procesos de la maquina 
fer@debian:~$ ps aux          

# Indica el pid (process id) del proceso (nombre) 
fer@debian:~$ pidof firefox 

# Termina el proceso con pid 2345
fer@debian:~$ kill -9 2345

# Terminar proceso por nombre (firefox)
fer@debian:~$ killall firefox 
</code>

==== Modificar permisos de archivos ====
=== chmod ===
Cambia los permisos de un fichero
{{ :unidad4:permisos-lsl.png?400 |}}
{{ :unidad4:permisos-file.png?400 |}}

^Permiso^para fichero^para directorio^
|r (read)| ver el contenido (cat) |ver los ficheros del directorio (ls)|
|w (write)| modificar el contenido | crear o eliminar ficheros del directorio|
|x (execute)| ejecutar el fichero| acceder al directorio (cd)|

Tipos de usuarios
^Usuario/Grupo^ Representación^ Ejemplo^
|u|usuario propietario| chmod u=rx fichero|
|g|grupo propietario|chmod g-w fichero|
|o|resto de usuarios|chmod o+rx fichero |
|a|los 3 grupos anteriores|chmod a=r|

<code bash>
#Añado permiso de ejecución al usuario propietario
fer@debian:~$ chmod u+x fichero.txt

#Quito el permiso de lectura al grupo propietario
fer@debian:~$ chmod g-r fichero.txt

#Quito el permiso de lectura y de ejecución al resto de usuarios
fer@debian:~$ chmod o-rx fichero.txt

#Añado permiso de escritura a los 3 tipos de usuarios (a -> all)
fer@debian:~$ chmod a+w fichero.txt

#Solo lectura y escritura para el usuario propietario
fer@debian:~$ chmod u=rw fichero.txt

#Puedo hacer cualquier combinación
fer@debian:~$ chmod u=rw,g=rw,o=r fichero.txt
</code>

También se pueden indicar los permisos mediante numeros

^valor octal^ permiso^
|0|- - -|
|1|- - x|
|2|- w -|
|3|- w x|
|4|r - -|
|5|r - x|
|6|r w -|
|7|r w x|

<code bash>
fer@debian:~$ chmod 777 fichero.txt
fer@debian:~$ ls -l fichero.txt
-rwxrwxrwx 1 fer fer 0 2018-02-07 22:34 fichero.txt

fer@debian:~$ chmod 664 fichero.txt
fer@debian:~$ ls -l fichero.txt
-rw-rw-r-- 1 fer fer 0 2018-02-07 22:34 fichero.txt

fer@debian:~$ chmod 750 fichero.txt
fer@debian:~$ ls -l permissions.txt
-rwxr-x--- 1 fer fer 0 2018-02-07 22:34 fichero.txt
</code>
=== chown ===
Cambia el usuario propietario de un fichero
<code bash>
fer@debian:~$ ls -l fichero1
-rw-r--r-- 1 fer fer 0 2018-08-06 14:11 fichero1
fer@debian:~$ chown laura fichero1
fer@debian:~$ ls -l fichero1
-rw-r--r-- 1 laura fer 0 2018-08-06 14:11 fichero1
</code>

=== chgrp ===
Cambia el grupo propietario de un fichero
<code bash>
fer@debian:~$ ls -l fichero2
-rw-r--r-- 1 fer fer 185 Apr 8 18:46 fichero2
fer@debian:~$ chgrp laura fichero2
fer@debian:~$ ls -l file2
-rw-r--r-- 1 fer laura 185 Apr 8 18:46 fichero2
</code>



==== Shell Script ====
Un //shell script// es un fichero de texto ejecutable desde el ''shell'' de linux. Actualmente el shell por defecto es ''bash''

Para crear un shell script solo debemos crear un fichero de texto que contenga como primera línea:
<code bash>
#!/bin/bash

#A continuación indico los comandos que quiero ejecutar
</code>

Para poderse ejecutar, debe tener permisos de ejecución. Se ejecuta indicando su ruta y el nombre del fichero.
==== Comandos de superusuario ====
=== sudo ===
Permite ejecutar órdenes de superusuario (root)
<code bash>
#Añado a un nuevo usuario
fer@debian:~$ sudo adduser fernando
</code>

=== su ===
Permite cambiar de usuario, o loguearte como (root)
<code bash>
#Cambio al usuario fernando (pide contraseña)
fer@debian:~$ su fernando

#Me logueo como superusuario (root) (Desactivada en Ubuntu)
fer@debian:~$ su
</code>
=== passwd ===
Permite cambiar la contraseña de los usuarios
<code bash>
#Modifico la contraseña del usuario fernando
fer@debian:~$ passwd fernando

#Modifico la contraseña del usuario actual
fer@debian:~$ passwd
</code>

==== Administrar usuarios/grupos ====
===adduser===
Permite crear nuevos usuarios y añadirlos a grupos existentes. Siempre que se crea un usuario se crea su grupo primario, que tiene el mismo nombre que el usuario.
<code bash>
#Crear un nuevo usuario fer2 (indicamos la contraseña para el nuevo usuario)
#Automáticamente se crea el grupo fer2
fer@debian:~$ adduser fer2

#Añadir el usuario fer al grupo fer2
fer@debian:~$ adduser fer fer2

</code>
===deluser===
Permite eliminar usuarios existentes o eliminarlos de un grupo. Al eliminar un usuario también se borrará su grupo primario, siempre que no haya más usuarios en ese grupo.
<code bash>
#Eliminar al usuario fer2
#Su grupo primario (fer2) no se eliminará porque tiene también al usuario fer
fer@debian:~$ deluser fer2

#Eliminar al usuario fer2 y también su directorio HOME
fer@debian:~$ deluser fer2 --remove-home

#Elimino al usuario fer del grupo fer2
fer@debian:~$ deluser fer fer2
</code>

===addgroup===
Crea grupos. Los grupos existentes se muestran en el fichero /etc/group
<code bash>
#Creo el grupo trabajo
fer@debian:~$ addgroup trabajo
</code>

===delgroup===
Elimina grupos. No puede eliminar un grupo si su usuario primario (el creador del grupo) aun pertenece a él.
<code bash>
#Elimino el grupo fer
#No se permite, porque el usuario fer (usuario primario del grupo) aun está en el grupo
fer@debian:~$ delgroup fer

#Elimino el grupo trabajo
fer@debian:~$ delgroup trabajo
</code>

=== Mostrar grupos de un usuario ===
<code bash>
#Muestro los grupos del usuario fer
fer@debian:~$ groups fer

#Muestro la información del usuario fer (también se muestran sus grupos)
fer@debian:~$ id fer
</code>
====Red====
<code bash>
#Mostrar interfaces de red
fer@debian:~$ ifconfig

#Mostrar interfaces de red inalámbricas
fer@debian:~$ iwconfig

#Mostrar direcciones de red
fer@debian:~$ ip addr show

#Mostrar usuarios conectados a mi sistema
fer@debian:~$ who
</code>
==== Administrar servicios ====
=== Arrancar y parar servicios ===
Con los comandos ''service'' y ''systemctl'' puedo gestionar servicios (damons o demonios)
<code bash>
#Reiniciar el servidor ssh
fer@debian:~$ service ssh restart

#Comprobar estado de servidor mysql
fer@debian:~$ service mysql status

#Comprobar estado de todos los servicios (+ -> arrancado, - -> parado)
fer@debian:~$ service --status-all

#Comprobar estado de servidor postgreSql
fer@debian:~$ systemctl status postgres

#Parar servidor web
fer@debian:~$ systemctl stop httpd

#Arrancar servidor mysql
fer@debian:~$ systemctl start mysql
</code>

El algunos sistemas linux el paquete ''systemd'' para usar el comando ''systemctl'', no viene con la distribución. Debemos instalarlo: ''apt-get install systemd''

===Niveles de ejecución===
En linux existen normalmente 7 diferentes niveles de ejecución. Se puede entender como los modos "a prueba de fallos", a prueba de fallos con red", "a prueba de fallos con simbolo del sistema", etc, que existen en Windows. 

Cada nivel de ejecución arranca servicios y configuraciones concretas. A partir de Ubuntu 16, los tradicionales niveles de ejecución se han cambiado por el concepto de **targets**. En la siguiente tabla vemos una correspondencia:
   ┌─────────┬───────────────────┐
   │Runlevel │ Target            │
   ├─────────┼───────────────────┤
   │0        │ poweroff.target   │
   ├─────────┼───────────────────┤
   │1        │ rescue.target     │
   ├─────────┼───────────────────┤
   │2, 3, 4  │ multi-user.target │
   ├─────────┼───────────────────┤
   │5        │ graphical.target  │
   ├─────────┼───────────────────┤
   │6        │ reboot.target     │
   └─────────┴───────────────────┘

<code bash>
#Comprobar mi nivel de ejecución
fer@debian:~$ runlevel

#Modificar el nivel de ejecución temporalmente, al 3 en este caso
fer@debian:~$ init 3

#Ubuntu 16 y posteriores
#Comprobar el target por defecto
fer@debian:~$ systemctl get-default

#Modificar el target (nivel de arranque)
fer@debian:~$ systemctl set-default graphical.target
</code>

=== Comprobar versión del kernel y sistema operativo ===
<code bash>
#Comprobar versión del kernel de linux
fer@debian:~$ uname -r

#Comprobar versión de linux
fer@debian:~$ lsb_release
</code>
==== Instalación de paquetes ====

=== apt  (Advanced Package Tool)===
Es el gestor de paquetes de sistemas basados en Debian, como Ubuntu

Configuración

  * Las direcciones de los repositorios que tenemos para descargar paquetes están en el fichero ''/etc/apt/sources.list''
    
Repositorios de paquetes
<code bash>
#Actualizar repositorios: 
apt-get update

#Actualizar paquetes instalados:
apt-get upgrade
</code>
  

Búsqueda de paquetes
<code bash>
#Buscar paquetes: 
apt-cache search <cadena ó cadenas de búsqueda>

#Mostrar info de un paquete: 
apt-cache show <paquete>
</code>


Instalación / Desinstalación de paquetes (aplicaciones/librerías)
<code bash>
#Instalar un paquete: 
#Ejemplo: instalar el servidor ssh -> apt-get install openssh-server
apt-get install <paquete>
#Reinstalar un paquete: 
apt-get install <paquete> --reinstall
#Desinstalar un paquete: 
apt-get remove <paquete>
#Desinstalar un paquete y toda su configuración: 
apt-get remove <paquete> --purge
#Corregir errores de instalación: 
apt-get install -f 
#Actualizar a la siguiente versión del sistema: 
apt-get dist-upgrade [-u]
</code>


=== dpkg (Debian Packaging System) ===
Instalación / Desinstalación de paquetes //.deb// (aplicaciones/librerías)
<code bash>
#Instalar un paquete: 
dpkg -i <paquete.deb>
#Instalar un paquete "a la fuerza":
dpkg -i --force-all <paquete.deb>
# Desinstalar un paquete: 
dpkg -r <paquete>
#Corregir errores de instalación
dpkg --configure -a <paquete>
</code>

==== Empaquetadores (Compresores) ====
=== tar ===
Solo empaqueta, no comprime
  * Empaquetar: tar -cvf paquete.tar /dir/a/empaquetar/
  * Desempaquetar: tar -xvf paquete.tar
=== gunzip ===
Solo puedo comprimir ficheros sueltos
  * Comprimir: gzip index.php
  * Descomprimir: gzip -d index.php.gz
=== tar y gunzip ===
Empaqueta y comprime
  * Comprimir: tar -czvf empaquetado.tar.gz /dir/a/comprimir/
  * Descomprimir: tar -xzvf archivo.tar.gz
=== zip ===
Comprime
  * Comprimir: zip archivo.zip directorio
  * Descomprimir: unzip archivo.zip

===== Editor de texto vi =====
El editor de texto //vi// es un editor en modo terminal existente en todos los sistemas basados en Unix. Permite editar, copiar, pegar, etc, y al estar en todos los sistemas conocer su funcionamiento es una salvaguarda ante operaciones de emergencia en diversos sistemas operativos. 

Existe una versión mejorada llamada //vim//, algo más fácil de usar, pero conociendo un funcionamiento básico de la original, podremos trabajar con cualquier otra versión.

Para abrir el vi podemos usar:
<code bash>
#Abrir el editor vi
fer@debian:~$ vi
#Abrir un archivo con el editor vi
fer@debian:~$ vi archivo
</code>

==== Modos de uso ====
Existen dos modos de operación en //vi//  :

  * **Modo Edición**: Para añadir texto al fichero.
  * **Modo Comando**: Para introducir órdenes que realizan funciones específicas de //vi//. También se conoce como //modo última línea//. 

El //modo edición// solo permite añadir texto en el lugar donde se encuentre el cursor. En principio no permite borrar texto ni moverse por el mismo, aunque depende de la versión del editor.

El //modo comando// es el modo en el que se abre el editor, y se accede a él pulsando la tecla ''Esc'' (Escape). Desde este modo se indice donde insertar, añadir o borrar texto, además de guardar el fichero, cerrar el editor, etc.

==== Modo comando (básico) ====
Para acceder al modo comando pulsa la tecla ''Esc''. Cuando arranco vi, me encuentro en este modo.
=== Guardar y salir ===
  * :w -> Guardo el contenido si ya he especificado un fichero.
  * :w datos.txt -> Guardo el contenido en el fichero //datos.txt//
  * :q -> cierro el editor, siempre que no haya modificaciones. Si las hay antes debo guardarlas.
  * :q! -> fuerzo el cierre del editor aunque haya modificaciones sin guardar.
  * :wq -> guardo cambios y cierro el editor

=== Desplazarse por el texto ===
Desde el modo comando nos podemos desplazar por el texto. Para desplazarse caracter a caracter puedo usar las flechas de dirección ó:

  * h -> me muevo un caracter a la izda
  * l -> me muevo un caracter a la dcha
  * k -> me muevo un caracter hacia arriba
  * j -> me muevo un caracter hacia abajo

=== Borrar texto ===

  * Caracteres
    * x -> borra el caracter sobre el que se situa el cursor.
    * X -> borra el carácter anterior a la posicion del cursor. 


  * Líneas
    * dd -> borra la línea en la que está el cursor.

  * Palabras
    * dw -> borra la palabra situada a continuación del cursor.
  

==== Modo edicion (básico) ====
Para acceder al modo edición desde el modo comando, debo pulsar alguna de las teclas para insertar texto:

=== Insertar texto ===

  * Insertar
    * i -> (insert) se inserta texto a la izquierda del cursor.
    * I -> se inserta texto al principio de una línea. 

  * Añadir
    * a -> (append) se inserta texto a la derecha del cursor.
    * A -> se añade texto al final de la línea en la que está el cursor. 

  * Insertar una línea
    * o -> (open) se inserta una línea debajo de la posición actual del cursor
    * O -> se inserta una línea encima de la actual posición del cursor. 



---- 

===== Prácticas =====
  - Administración de sistema Linux mediante terminal de comandos. (Prueba práctica)

----

(c) {{date> %Y}} Fernando Valdeón