Traballar con Ubuntu nas aulas de Teis

Carpeta persoal, perfil e carpetas de rede

Facernos administradores do equipo
Actualizar o sistema
Usar os privilexios administrativos. Su, sudo, sudo -s gksudo
Instalar e desinstalar paquetes
Instalación de paquetes dende o código fonte
Preparación dos discos externos usb
Instalar a impresora da aula
Pasos para instalar a última versión de VirtualBox en Ubuntu 12.04
Cambiar de lado os botóns das ventás sen cambiar de tema
Copia de seguridade periódica.

1. Carpeta persoal, perfil e carpetas de rede.

Cando iniciamos sesión co noso usuario do servidor, créase no disco duro local unha carpeta
co noso nome de usuario en /home.

Ao abrir a carpeta persoal (ver figura de arriba) podemos acceder a:

– A nosa carpeta persoal no servidor (na rede).
– A carpeta de recursos do grupo
– As carpetas virtual e progs que conteñen material necesario para a realización das
prácticas.

Debedes gardar os traballos, documentos, etc na carpeta persoal do servidor na rede. En caso
de problemas os equipos restáuranse e a información dos discos locais almacenada en
/home/xxxxxxxx pérdese. O que gardes no escritorio tamén pode desaparecer xa que se garda
dentro de /home/usuario/Escritorio.
Podedes ver tamén na figura a partición de datos NOCTURNO. Nesta partición crearemos as
máquinas virtuais para traballar. Normalmente, estes datos non desaparecerán, pero debemos
ter copia de seguridade no disco USB externo por se acaso.
2. Facernos administradores do equipo.

Nas novas imaxes, o grupo alumnos ten privilexios administrativos. O que ven a continuación
NON É PRECISO FACELO, pero é importante sabelo.

Igual que en Windows, en GNU/Linux hai usuarios/as 'normais', que poden manexar a máquina
pero non facer cambios no sistema e usuarios con privilexios administrativos que poden
realizar calquera tarefa.
En Windows, para conceder privilexios de administración a un usuario, o podemos meter no
grupo local 'Administradores'.
Cando instalamos Ubuntu, temos que dar un nome de usuario (nas máquinas de Teis, o nome
que se usou na instalación é 'administrador'). Ubuntu agrega este usuario a unha serie de
grupos do sistema para que poida facer todo tipo de tarefas.
Nun posto de traballo GNU/Linux, os usuarios e grupos gárdanse en dous arquivos de texto:

/etc/passwd contén a lista de usuarios/as coas súas características.

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
.
.
.
sshd:x:116:65534::/var/run/sshd:/usr/sbin/nologin
administrador:x:1000:1001:Administrador,,,,:/home/administrador:/bin/b
ash

Observa:
- O equivalente ao usuario 'Administrador' de Windows é 'root'. GNU/Linux non deixará que
iniciemos unha sesión en modo gráfico como 'root' pois isto sería perigoso para o sistema.
- O resto dos usuarios salvo o último (que é o que se crea cando facemos a instalación) son
'usuarios do sistema'. Úsanse para lanzar procesos do sistema.
- Podes ver no último usuario os detalles do mesmo como o nome completo, a ruta do
directorio particular de usuario (/home/administrador) e o intérprete de comandos por defecto
(/bin/bash). O 'x' que aparece detrás do nome de usuario é onde inicialmente GNU/Linux
gardaba o contrasinal (cifrado). Isto cambio posteriormente por motivos de seguridade. Por iso
aparece sempre 'x'.

/etc/group contén a lista dos grupos cos usuarios/as de cada un.

root:x:0:
.
.
adm:x:4:administrador
tty:x:5:
disk:x:6:
.
.
video:x:44:administrador
sasl:x:45:
.
.
virtualboxusers:x:1002:administrador
Observa:
- Cada grupo ten un número que o identifica.
- Ao final de cada liña está a lista de usuarios de cada grupo separados por ','.
- De momento ningún grupo ten máis dun usuario.
- O usuario 'administrador' é un usuario administrativo porque está en determinados grupos.

Se queremos ser administradores da máquina, o mellor é meternos en todos os grupos nos

que aparece 'administrador'.

Editar o ficheiro /etc/group con gedit:

Iniciamos sesión como administrador/renaido
Pulsamos ALT+F2 (Executar) e escribimos:
gksudo gedit /etc/group
Buscar - Substituír

(Podemos incluír a máis dun usuario, separándoos por ',')

Hai que realizar esta operación con coidado posto que podemos deixar inservible o ficheiro
/etc/group e por tanto tamén o sistema.
Se algo foi mal, podes pulsar CTRL+Z para desfacer os cambios e probar de novo.

Xa podemos iniciar sesión co noso usuario. Cando teñamos que realizar unha operación que
requira privilexios administrativos, Ubuntu pediranos o noso contrasinal para confirmar a
acción.
3. Actualizar o sistema.
As imaxes de Ubuntu están configuradas para actualizarse dende o repositorio local do IES de
Teis (máquina reposteis@ateis.local).

Isto permitirá que instalemos paquetes sen ter conexión a Internet. Se incluímos algún
repositorio externo, para actualizar debemos solicitar ao profesor/a que nos dea saída a
Internet (POR EQUIPO).

IMPORTANTE!
Cando actualizamos, pode que o sistema faga algunha pregunta se non pode continuar de
forma automática. Debedes consultar sempre ao profesor/a antes de contestar.

Hai dúas cousas particularmente importantes:

• Cando se actualiza o paquete grub (xestor de arranque) o sistema preguntará onde
queremos instalar grub. NUNCA debemos instalar GRUB no sector mestre de arranque
(MBR) posto que substituiriamos a instalación de administración e o menú inicial de
arranque do sistema. O grub débese instalar unicamente na partición de GNU/Linux da
quenda correspondente:
• Diúrno /dev/sda5
• Nocturno /dev/sda6
• Cando se actualice o paquete pam-mount, Ubuntu detectará que hai cambios manuais
en /etc/pam.d/common-*
Estes cambios son importantes para que o sistema busque os usuarios/as no servidor.
Cando o instalador pregunte se queremos sobre-escribir os cambios locais a este
ficheiros DEBEMOS CONTESTAR QUE NON. Se tes dúbidas, cando apareza a
pregunta avisa ao profesor/a.

Para actualizar podemos usar o xestor de actualizacións (Sistema-Administración-Xestor de

actualizacións) ou nunha terminal...

sudo apt-get update

sudo apt-get upgrade

Podemos usar tamén o repositorio de Reposteis para actualizar ou instalar paquetes nas
máquinas virtuais.
Os sources.list das diferentes versións de Ubuntu para Reposteis está na rede, en VIRTUAL,
ImaxesCDROMS, GNULinux,sourceslist.teis. Para cambiar o repositorio podemos substituír o
ficheiro /etc/apt/sources.list polo que atoparemos na rede para a versión de GNU/Linux
adecuada.

Despois debemos facer clic en comprobar no xestor de actualizacións ou nunha terminal

executar apt-get update para que cargue o novo repositorio.
4. Usar os privilexios administrativos. Su, sudo, sudo -s gksudo
Para realizar tarefas administrativas podemos:
a) Converternos en root (su ou sudo -s)
b) Executar un comando como root (sudo, gksudo

su - Calquera usuario pode usar este comando para converterse en root (sempre que coñezas
o contrasinal de root). Por defecto Ubuntu non asigna un contrasinal a root polo que mentres
non lle asignemos un, non poderemos usar este comando. (Para asignarlle un contrasinal a
root podemos usar: sudo passwd root. O comando su abre unha nova sesión do shell
(intérprete de comandos) como root. Para rematar esta sesión: exit, logout ou CTR+D e
seremos de novo o usuario orixinal.

sudo -s - Só pode executar este comando un usuario que estea autorizado (un dos
privilexios administrativos é actuar como root). O resultado é o mesmo que con su, pero o
contrasinal que escribimos é o noso. Non temos por que coñecer o contrasinal de root (root
pode non ter contrasinal e isto funciona igual).

sudo comando - Executase comando como usuario. Ao rematar a execución de comando

volvemos ao shell orixinal co noso usuario.

gksudo comando - O mesmo que sudo pero pódese lanzar dende o entorno gráfico con
ALT+F2 (executar comando).

Exemplos:
gksudo gedit /etc/group
Neste caso o comando é gedit /etc/group (editar co editor gedit o ficheiro group na
carpeta /etc).

gksudo nautilus
Lanza un explorador de arquivos de gnome (nautilus) como root (Non vos recomendo facer
isto. Podemos danar o sistema borrando ou movendo algunha carpeta).

sudo nano /etc/group

Edita o ficheiro /etc/group como root usando o editor nano.

sudo passwd root

Asignar un contrasinal a root ou cambiar o contrasinal de root.
5. Instalar paquetes, actualizar o sistema.
Ubuntu usa o sistema de instalación de paquetes de Debian. A continuación veremos os
comando máis habituais para localizar e instalar paquetes dos repositorios, así como actualizar
o sistema e instalar paquetes tipo "deb".

Repositorios:
No ficheiro /etc/apt/sources.list hai unha lista de repositorios para usar co programa
apt. Algo como:

#############################################################
################### OFFICIAL UBUNTU REPOS ###################
#############################################################

###### Ubuntu Main Repos

deb http://es.archive.ubuntu.com/ubuntu/ lucid main restricted
universe multiverse

###### Ubuntu Update Repos

deb http://es.archive.ubuntu.com/ubuntu/ lucid-security main
restricted universe multiverse
deb http://es.archive.ubuntu.com/ubuntu/ lucid-updates main restricted
universe multiverse
deb http://es.archive.ubuntu.com/ubuntu/ lucid-proposed main
restricted universe multiverse
deb http://es.archive.ubuntu.com/ubuntu/ lucid-backports main
restricted universe multiverse

###### Ubuntu Partner Repo

deb http://archive.canonical.com/ubuntu lucid partner

Nesta páxina podemos seleccionar as os repositorios que precisemos indicando o pais no que
estamos e xerar un ficheiro 'sources.list' adecuado para a nosa versión de Ubuntu.

No servidor teisfs (reposteis) están os repositorios de Ubuntu 10.04, 12.04 e 14.04. Se

modificamos o sources.list para que apunte a reposteis.ateis.local descargaremos paquetes
moi rápido e sen estar conectados a Internet. Os sources.list das imaxes das aulas xa apuntan
a reposteis.ateis.local.

Buscar paquetes (apt-cache search)

Queremos buscar o paquete para xestionar os efectos de escritorio de compiz. Comezamos
buscando os paquetes que teñan a palabra compiz:
apt-cache search compiz
Aparece unha lista demasiado grande. Podemos filtrar esta lista usando o comando grep para
que so se mostren as liñas que conteñan a palabra 'manager':
apt-cache search compiz | grep manager
A lista redúcese e localizamos o nome exacto do paquete:
compizconfig-settings-manager - Compiz configuration settings manager

Instalar un paquete (apt-get install) (debemos ser root ou ben usar sudo diante do comando
apt-get):
apt-get install compizconfig-settings-manager
Apt-get comprobará se este paquete depende doutros paquetes. Se é así proporá a instalación
de todos os paquetes necesarios e preguntará se queremos instalalos.
Eliminar un paquete (apt-get remove, apt-get purge) (debemos ser root ou ben usar sudo
diante do comando apt-get):
apt-get remove compizconfig-settings-manager
ou ben
apt-get purge compizconfig-settings-manager
A diferenza entre estes dous comandos é que purge borrará os ficheiros de configuración do
paquete. Isto é importante se un paquete non funciona correctamente e queremos re-instalalo
coa configuración inicial. Apt-get remove borrará os executables pero respecta os cambios na
configuración e se instalamos de novo o paquete a configuración non cambia.

Actualizar o sistema (apt-get update/upgrade) (debemos ser root ou ben usar sudo diante
do comando apt-get):
apt-get update
Este comando descarga a lista de paquetes dispoñibles actualizada dos repositorios activos en
'sources.list'. Imprescindible antes de instalar/eliminar paquetes ou actualizar o sistema.
apt-get upgrade
Este comando busca nos repositorios as actualizacións dispoñibles para todos os paquetes
instalados no sistema e deixa o sistema completamente actualizado.
Se traballamos co entorno gráfico, o 'Xestor de actualizacións' de Gnome fai automaticamente
o traballo de apt-get update/upgrade.

Instalar un paquete tipo deb (dpkg -i).

Non todo o software que podemos instalar en Ubuntu está nos repositorios. Moitas veces
atoparemos paquetes para Ubuntu en formato 'debian package' (.deb).
Para instalar un paquete deste tipo usaremos o comando dpkg.
Imaxina que queremos instalar webmin. Descargamos o paquete deb da páxina de webmin ...
dpkg -i webmin_1.560_all.deb
Dpkg non fai como apt que busca dependencias nos repositorios. Se detecta que este paquete
depende doutros que non temos instalados avisará e non rematará a instalación correctamente
(é o caso do paquete webmin). Neste caso podemos localizar e instalar as dependencias ou
ben deixar que apt o faga por nos (isto non sempre é posible, pero neste caso si).
O comando
apt-get -f install
Busca nos repositorios os paquetes dos que depende webmin (dpkg o deixa pendente de
configurar e apt-get o detecta) e os instala.

Eliminar un paquete instalado con dpkg (dpkg -r)

dpkg -r webmin_1.560_all
ou ben
dpkg --purge webmin
A diferenza é a mesma que no caso de apt-get remove e purge.
Hai que escribir o nome do paquete correctamente. Podemos usar dpkg -al | grep xxx para
localizalo.

Eliminar as dependencias (que xa non precisamos) instaladas para un paquete

No caso de webmin, apt-get -f install instalou os paquetes dos que dependía. Una vez
desinstalado, xa non son necesarios. Podemos desinstalalos con:
apt-get autoremove
Eliminará os paquetes instalados como 'dependencias' de outro cando xa non se precisan.
Comprobar se temos instalado un paquete (dpkg -al | grep xxx).
dpkg -al | grep webmin
ii webmin 1.560 web-based administration interface for Unix
Fíxate no nome do paquete (despois de ii): webmin
Podemos desinstalalo con
dpkg -r webmin
Imaxina que queres saber que paquetes tes instalados que teñan a palabra java:
dpkg -al | grep java
A lista pode ser longa. Podemos reducila filtrado de novo para buscar, por exemplo os que
conteñan 'plugin':
dpkg -al | grep java | grep plugin

Reconfigurar un paquete xa instalado.

Cando instalamos un paquete, hai un proceso de configuración no que ás veces debemos
introducir datos. Pode ser interesante lanzar de novo o proceso de configuración para un
paquete se nos trabucamos a primeira vez. Isto faise con:
dpkg-reconfigure paquete

Instalar os encabezados do núcleo (linux-headers) para poder compilar módulos.

O que coñecemos normalmente como controladores de dispositivo ou drivers, en GNU/Linux
chamámoslle módulos. Un módulo é capaz de xestionar un determinado hardware e cando o
sistema precisa acceder a este hardware, o núcleo chama ao módulo. Os módulos deben ser
compatibles coa versión do núcleo (kernel) que estamos usando e por tanto, se cambiamos de
núcleo, debemos dispoñer de módulos compatibles co mesmo. Para conseguir isto debemos
compilar de novo os módulos para o núcleo actual.
Para compilar un módulo precisamos os ficheiros de cabeceira (headers) en linguaxe C
correspondentes ao núcleo que estamos usando. En Ubuntu, estes ficheiros están nun paquete
que se chama linux-headers-versión_do_núcleo, onde versión_do_núcleo son uns números e
letras que indican exactamente o núcleo que estamos usando.
Para ver a versión do núcleo actual podemos usar o comando uname -r:

$ uname -r
3.2.0-31-generic

Para instalar os encabezados deste núcleo teriamos que escribir:

$ sudo apt-get install linux-headers-3.2.0-31-generic

O shell de GNU/Linux dispón dunha característica moi interesante que consiste en poder
incorporar a unha liña de comando a saída doutro comando. Isto conséguese encerrando o
comando entre acentos graves:
`comando`
ou usando esta sintaxe:
$(comando)

Cando o shell atopa dentro dunha liña escrita `comando` ou $(comando) o substitúe
automaticamente polo que aparece en pantalla ao executar comando.

Podemos usar esta característica para non ter que escribir a versión do núcleo que proporciona
directamente uname -r. Os seguintes comandos son equivalentes ao de arriba:

$ sudo apt-get install linux-headers-`uname -r`

$ sudo apt-get install linux-headers-$(uname -r)
Algúns programas que traballan directamente co hardware como VirtualBox precisan que este
paquete estea instalado para compilar os módulos.

Instalación de paquetes dende o código fonte.

Moitos paquetes están dispoñibles na súa última versión sen compilar. Veñen preparados para
a súa configuración e compilación nas diferentes distribucións de GNU/Linux.
Este tipo de paquetes descárganse normalmente empaquetados e comprimidos coa extensión
.tar, .tar.gz ou .tgz

.tar – empaquetado co comando tar

.tar.gz ou .tgz – empaquetado con tar e comprimido

Ás veces tamén pode ser un .tar comprimido con bzip2 (.tar.bz2). Neste aso debemos
descomprimir previamente o bz2 dende o entorno gráfico ou con:

$ bunzip2 paquete.tar.bz2

paquete.tar.bz2 pasa a ser paquete.tar

Para compilar un paquete precisaremos ter instalados os encabezados do núcleo e tamén

unha serie de programas como o compilador de C, o montador, make, etc...
Todas estas ferramentas, están en Ubuntu nun paquete chamado build-essential que podemos
instalar mediante:

$ sudo apt-get install build-essential

Unha vez descargado o ficheiro .tar.gz ou .tgz, ou .tar, na nosa carpeta persoal, abrimos unha
terminal e (unha de tres, dependendo da extensión do paquete):

$ tar -xzvf paquete.tgz

$ tar -xzvf paquete.tar.gz
$ tar -xvf paquete.tar

Fíxate que usamos sempre o comando tar coas opcións x (extraer), v (ver, mostrar o que fai) e
f (file) seguido do nome do paquete.
No caso de que o tar estea comprimido debemos usar tamén a opción z (descomprimir).

Tamén podemos abrir o paquete no entorno gráfico e arrastrar o seu contido á nosa carpeta
persoal.

Unha vez descomprimido, atoparemos dentro un ou varios ficheiros de información

normalmente en maiúsculas e de nome (tamén habitualmente) README ou INSTALL onde se
explica como instalar o paquete e algunhas indicacións específicas para as diferentes
distribucións.

En xeral, os paquetes traen un script de nome configure que prepara todo para compilar o
paquete na distribución que esteamos usando. Este script pode ter moitas opcións para
configurar o paquete de acordo coas nosas necesidades. Estas opcións poden vir explicadas
nos ficheiros de información citados anteriormente ou na documentación do paquete.
Os pasos para compilar e instalar un paquete, nunha porcentaxe moi alta de casos son
(situándose previamente na carpeta descomprimida do paquete):

$ ./configure
$ make
$ sudo make install

• configure prepara o paquete para a compilación (non modifica o sistema). Debemos

estar atentos por se detecta algún problema (paquetes non instalados e necesarios, por
exemplo). Se a saída é moi extensa podemos chamalo engadindo “| more” detrás para
que pare cada vez que se enche a pantalla.
• make compila e prepara o paquete para instalar (non modifica o sistema)
• make install instala o paquete (por iso debemos executalo con sudo).

As instrucións anteriores son aplicables a moitos paquetes de GNU/Linux, pero sempre

debemos examinar antes a documentación que normalmente atoparemos na web do proxecto.

Moitas veces, os paquetes, para poder funcionar precisan que estean instalados no sistema
outros paquetes (o que chamamos dependencias).
O comando apt ten unha forma que permite instalar as dependencias para compilar os
paquetes (sempre e cando algunha versión do paquete que queremos instalar estea nos
repositorios). A forma de instalar as dependencias para compilar un paquete é:

$ sudo apt-get build-dep paquete

Instalación da última versión de Wireshark.

A modo de exemplo compilaremos a última versión do paquete Wireshark.

Comproba a versión dispoñible nos repositorios de Ubuntu mediante:

apt-cache show wireshark

Comproba que non é a última

Descarga a última versión de Wireshark de:

https://1.eu.dl.wireshark.org/src/

O paquete é wireshark-xxxx.tar.bz2 ou o .xz

No mesmo ftp anterior atoparás un enlace a un ficheiro 'SIGNATURES-xxx.txt'. Aí están as

sumas de comprobación con diferentes métodos para comprobar a autenticidade do paquete
descargado. Abre o ficheiro e localiza a suma md5 do paquete descargado.

Fai a suma de comprobación co comando md5sum:

$ md5sum wireshark-xxx.tar.bz2 (ou .xz)

Comproba o resultado. Deben coincidir.

Se descargaches o bz2:

Descomprimimos o tar (.bz2):

$ bunzip2 wireshark-xxx.tar.bz2
 Extraemos o código fonte do tar:

$ tar -xvf wireshark-xxx.tar

En caso de descargar o .xz

$ tar –xz -xvf wireshark-xxx.tar.xz

Instalamos o necesario para compilar:

$ sudo apt-get install build-essential linux-headers-`uname -r`

Instalamos as dependencias para construír o paquete:

$ sudo apt-get build-dep wireshark

Pasamos á carpeta descomprimida

$ cd wireshark-xxx

Configuramos:

$ ./configure

Este script tratará de crear os ficheiros 'make' para compilar a aplicación no teu sistema e
avisará se falta algo importante. Debemos instalar un paquete (qt5-default).

Compilamos:

$ make

Instalamos:

$ sudo make install (tardará)

Para probar chama ao programa wireshark e comproba a versión.

6. Preparación dos discos externos usb:
(Ver antes "Dispositivos en GNU/Linux")
Cando inserimos o disco USB, Gnome monta cada partición do disco (sempre que recoñeza o
sistema de arquivos no que se lle deu formato) na carpeta /media.
Mediante a utilidade "Utilidade de disco" comprobaremos o estado do disco
Debe haber dúas particións DIURNO e NOCTURNO ou IA2DA e IANA, etc.
Se non é así hai que dividir o disco en dúas particións, darlles formato e asignarlles unha
etiqueta. Por exemplo para o taller 1 (2º de ASIR) a partición de diúrno pode chamarse IA2DA e
a de nocturno IANA.

IMPORTANTE:
Antes de proceder fala co/a profesor/a para que comprobe como está o disco e se procede
facer ou non algún cambio. Se hai datos nalgunha partición hai que respectalos sempre salvo
indicacións do/a profesor/a.

Primeiro localizamos o disco na Utilidade de disco (no panel da esquerda):

Neste exemplo, eliminaremos a única partición dun disco de 80 Gb e crearemos dúas de 40Gb
cada unha con formato NTFS e as etiquetas IA2DA e IANA. (Se o disco fora de 500Gb
creariamos dúas particións de 250Gb cada unha).
Se as particións xa estiveran creadas, bastaría con desmontar e 'Dar formato' (NTFS) á
partición que corresponda (diúrno ou nocturno) poñéndolle o nome que se indica (IANA ou
IA2DA).

Primeiro facemos clic en "Desmontar o volume". A continuación en "Borrar partición".

A continuación facer clic en "Crear partición":

E indicar os datos:
O resultado:

O disco externo queda preparado. Usarémolo para facer copia de seguridade.

7. Instalar a impresora da aula:
A impresora debería de estar xa instalada nas novas imaxes, pero veremos como instalar unha
impresora compartida por Windows en Ubuntu. Non uses este sistema. Mira abaixo.
Abre o administrador de impresoras

Engadir impresora

Impresora de rede - Windows printer via Samba (Impresora de Windows a través de Samba)
O servidor sempre é teis1 e a impresora:

Taller1 - IT1
Taller2 - IT2
Taller3 - IT3
....
Podes pulsar 'Verify' para comprobar que a impresora existe (Fíxate no nome da impresora que
queres instalar. Non copies o da imaxe de abaixo).
Escolle o controlador:
Fabricante (COMPROBA A IMPRESORA, PODE CAMBIAR)

Modelo (COMPROBA A IMPRESORA, PODE CAMBIAR)

(Non imprimas unha páxina de proba. Xa a probarás cando precises imprimir algo)
Método recomendado para as aulas de TEIS:
En vez de escoller impresora compartida de Windows, escoller 'Internet Printing protocol' e no
recadro correspondente poñer:

http://teis1:631/printers/IT1

Só cambia o nome da impresora segundo o taller. O resto (instalación do controlador) é igual

que indicado anteriormente.
8. Pasos para instalar a última versión de VirtualBox en Ubuntu 16.04

Instalaremos manualmente o paquete copiando da rede a última versión.

Podes copiar o paquete descargado da rede (pregunta ao profesor) ou descargar Virtualbox

(Busca en Google virtualbox e localiza a páxina de descargas de Oracle. Fai clic no enlace de
'Linux hosts'...
Escolle Ubuntu 16.04... (Ollo! A figura mostra a versión 10.04)

Selecciona gardar o ficheiro.

Descarga tamén o Extension Pack...

Escolle gardar o ficheiro...

Antes de instalar virtualbox debemos instalar o paquete que contén os encabezados no núcleo
actual. Isto débese a que virtualbox usa módulos que debe compilar para o núcleo que
estamos usando. O paquete chámase linux-headers-numeros-do-nucleo.
Os números do núcleo podémolos ver co comando uname -r.

Para instalar os encabezados do núcleo actual escribiremos:

sudo apt-get install linux-headers-`uname -r`

Cando remate a descarga (ou a copia dende a rede) abre unha terminal e escribe (supoñendo
que todo está copiado ou descargado na carpeta Descargas):

$ sudo dpkg -i Descargas/virtualbox(pulsa TAB para completar o nome)

Instalarase VirtualBox.

Unha vez instalado comproba que funciona. Pulsa a tecla Start e escribe virt

Unity busca a aplicación por ti. Pulsa enter.

Agora sitúate no Launcher sobre a icona de VirtualBox, fai clic co botón dereito e escolle
Manter no iniciador. Agora só tes que facer clic nesta icona para abrir VirtualBox.

Agora instala o extension pack...

Primeiro o localizamos...
E despois o
instalamos...

Para que funciona o usb debes engadir o teu usuario ao grupo vboxusers. (Isto non é necesario
na instalación da aula. O teu usuario xa está no grupo vboxusers). Abre unha terminal e:

$ sudo usermod -G vboxusers usuario

(cambia usuario polo teu nome de usuario)

Asegúrate de que o disco USB está conectado e a partición de diúrno ou nocturno montada.
Aplicativos-Accesorios-Virtualbox-OSE
Ficheiro - Preferencias
Establece a ruta das máquina e dos discos ás carpetas que creaches dentro da carpeta do
módulo no teu disco USB.
Neste caso o módulo é ASO e o grupo IANA. Ollo coas maiúsculas e minúsculas porque
GNU/Linux distingue entre unhas e outras nos nomes de arquivo e carpeta.
Nas novas versións de Virtualbox, a imaxe de abaixo cambia e só nos pide unha carpeta na
que gardará discos e máquinas. Escolle a carpeta Virtualbox creada en ASO anteriormente...

Importar unha máquina creada:

Na unidade de rede 'Virtual' (hai un acceso directo no teu escritorio) hai dúas carpetas que
usaremos moito.
ImaxesCDROMS contén imaxes iso dos cds de instalación de moitos sistemas operativos e
utilidades.
Virtualbox contén unha serie de máquina xa instaladas e preparadas para importar dende
Virtualbox.

Localiza en Virtualbox, dentro de Windows, o Windows7 de 32 bits.

Copia esta carpeta e pégaa no escritorio tardara un pouco).
Cando remate, en virtualbox:
Ficheiro - Importar servizo virtualizado.
Pulsa o botón "escoller"
Navega ata a carpeta que pegaches no teu escritorio, selecciona o ficheiro que hai dentro e fai
clic en abrir.

A importación tardará un pouco. Proba a prender a máquina virtual.

Agora podes eliminar a carpeta Windows7_32 do teu escritorio.
9. Cambiar de lado os botóns das ventás sen cambiar de tema.
Se non che gusta o estilo "MAC" do tema que trae Ubuntu por defecto (botóns de minimizar,
maximizar e pechar no lado esquerdo), podes cambiar este comportamento executando o
seguinte, nunha terminal ou con ALT+F2:
gconftool-2 --type string --set /apps/metacity/general/button_layout
"menu:minimize,maximize,close"
Para deixalo como estaba:
gconftool-2 --type string --set /apps/metacity/general/button_layout
"maximize,minimize,close:menu"

10. Copia de seguridade.

Como xa se explicou neste documento, os datos gardados fora da rede poden desaparecer do
equipo local por moitos motivos. Cando un equipo non funciona ben cámbiase por un de
reposto (que non ten eses datos). Tamén pode que o disco duro se estropee.

Para non perder tempo e non ter que repetir os traballos convén que teñamos copia de
seguridade de todo o que facemos.

O que vos propoño é SINCRONIZAR cada día (ou coa periodicidade que considere cada un)
os datos da partición (NOCTURNO, neste caso) co disco externo usb. Sincronizar quere dicir
que só se copia o que cambia. Coas máquinas virtuais hai un problema: Unha máquina virtual
de Virtualbox pode ocupar varios Gb. Cada vez que a iniciamos o ficheiro que conten o disco
duro cambia, a sincronización detecta o cambio e o copia enteiro. Isto leva moito tempo.

Para solucionar isto, convén facer cando menos UNHA INSTANTÁNEA de cada máquina
virtual. Cando facemos unha instantánea, Virtualbox crea unha carpeta e garda todas as
modificacións que se fagan nesta carpeta SEN TOCAR o ficheiro (grande) do disco duro. Isto
reduce moito o tempo de copia.

Tamén é boa idea copiar a carpeta /home/usuario xa que nela está o que gardemos no
escritorio, documentos locais, preferencias de Ubuntu, etc...

Usaremos o programa rsync. Para instalalo:

apt-get install rsync (ou ben centro de software de Ubuntu)

Crea o seguinte script co teu editor de textos preferido e gárdao na túa carpeta persoal:

sincroniza.sh
#!/bin/bash
# Sincroniza a carpeta Aso da partición de NOCTURNO
# e copia o home do usuario
USER=damaso
GRUPO=IANA
QUENDA=NOCTURNO

# Comprobar se o disco está enchufado

if mount | grep $GRUPO
then
# MONTADO
echo Esta montado. Hai que copiar
rsync -av --delete --progress /media/$QUENDA/ASO/ /media/$USER/$GRUPO/ASO
tar -cvzf /media/$USER/$GRUPO/ASO/$USER.tar.gz /home/$USER --exclude=.cache --exclude=.dbus
--exclude=.rnd --exclude=Trash --exclude=.gvfs --exclude=.gnupg
else
# NON MONTADO
echo O disco USB non está enchufado. Non se pode copiar.
fi
echo Pulsa ENTER para finalizar...
read x

Localiza este ficheiro na túa carpeta persoal, vai ás propiedades e activa o permiso de
EXECUCIÓN.
Para lanzar o script podes abrir unha terminal (CTRL+ALT+T) e escribir:

./sincroniza.sh

Para que funcione todo:

• A partición local debe chamarse como indica QUENDA (IANA, neste caso) (por defecto
chámase así)
• A partición no disco USB debe chamarse como indica GRUPO
• O nome de usuario debe ser o que se indica en USER
• Ollo ás maiúsculas e minúsculas

Este script comprobará que o disco usb está montado. En caso contrario non copiará.

Facer instantáneas das máquinas antes de comezar o traballo

VirtualBox garda as máquinas virtuais cada unha nunha carpeta. Hai dous ficheiros
importantes, un con extensión vbox e un ou varios con extensión vmdk que se corresponden
cos discos duros. Pode haber un ficheiro temporal de VirtualBox con extensión .vbox-prev.

Cando arrancamos a máquina, o ficheiro ou ficheiros .vmdk se modifican (só con acender a
máquina). Estes ficheiros son bastante grandes e ocuparán dende uns bytes cando o disco non
ten nada ata moitos Gb cando o disco está cheo.

O noso programa de copia sicroniza estes arquivos co disco externo. Cando detenta unha
variación aínda que sexa de 1 byte copiará o ficheiro completo o que fará que a copia tarde
moitos minutos.

Cando creamos unha instantánea de volume con VirtualBox, os arquivos vmdk quedan
bloqueados e non se modifican máis. Os cambios con respecto aos discos orixinais ou á última
instantánea, gárdanse na carpeta Snapshots cun nome {secuencianumerica}.vdi onde
secuencianumerica identifica a instantánea creada.

Se cada día, antes de comezar o traballo, facemos unha instantánea de cada máquina, a copia
só copiará os cambios do días. Ademais, se estropeamos algunha das máquinas sempre
podemos volver ao inicio da clase e comezar de novo.

Este pequeno script fará unha instantánea de cada unha das máquinas que teñamos
rexistradas.
#!/bin/bash
# Garda lista de máquinas en maquinas.txt
vboxmanage list vms > maquinas.txt
# Percorreo o ficheiro lendo o nome de máquina e a súa ID
while IFS={ read MAQUINA ID
do
# Garda a data en AGORA
AGORA=`date +"%m-%d-%Y%T"`
# Prepara o nome da instantánea
NOME_INSTANTANEA="Instantanea_$AGORA"
# Crea a instantánea
VBoxManage snapshot {$ID take \"$NOME_INSTANTANEA\"
done < maquinas.txt

Podes crear un novo script fotos.sh co seu lanzador igual que sincroniza.sh .
Abrir unha terminal
Usa o DASH ou pulsa CTR+ALT+T

Execución dun comando

Escribiremos o nome do comando seguido dun espazo e a continuación a información e
opcións do mesmo. Para que o comando funcione:
En GNU/Linux o comando debe estar nalgunha das rutas separadas por ':' que contén a
variable de entorno PATH. En caso contrario deberemos indicar a ruta. Se o comando está no
directorio actual podémolo executar con:

./comando

En CMD se o comando está nalgunha das rutas separadas por ';' que hai na variable de
entorno PATH funcionará. Se o comando está no directorio actual tamén funcionará. En caso
contrario deberemos indicar a ruta (incluíndo a unidade se non é a actual).

Em PowerShell o comportamento é análogo a GNU/Linux pero as rutas sepáranse con “;”

como en CMD.

Opcións:
Windows (CMD e PowerShell) usa '/' para as opcións (tamén '–' algunhas veces).
GNU/Linux usa '-' ou '--' para as opcións

Rutas
Windows (CMD e PowerShell) usa '\' para referirse ao directorio raíz e para separar directorios
nas rutas
GNU/Linux usa '/' para referirse ao directorio raíz e para separar directorios nas rutas

Se queremos indicar a ruta completa debemos comezar por '/' (GNU/Linux) ou '\' (Windows)
En Windows a ruta debe comezar por unha letra e ':' se queremos indicar unha unidade distinta
da actual. Por exemplo: c:\windows ou d:\nocturno.

Para indicar unha ruta partindo da carpeta actual comezaremos SEN '/' ou '\' ou ben con './' ou
'.\'.

Nas rutas '.' significa directorio actual e '..' significa directorio anterior.

Variables de entorno
Son variables do sistema que gardan información importante. Podemos usar estas varaibles
nos scripts e podemos crear as nosas propias variables.

Variables de entorno

Acción GNU/Linux Windows PowerShell

variable=valor
$variable=”valor”
Asignar
set variable=valor
valor export
$variable=150
variable=valor

variable=
Remove-Variable -Name
Borrar set variable=valor
variable
export variable=

Mostrar unha echo $variable echo %variable% $variable

Mostrar
set set Get-Variable
todas

Mostrar as
que comezan set | findstr Get-Variable | Where {$_.Name
set | grep -i ^[a-z]
por unha “^[a-z]” -match “^[a-z]”}
letra

Mostrar as
que comezan Get-Variable | Where {$_.Name
por A -match “^[a-z]”}
(Windows set | grep -i ^A set | findstr “^a”
ignora Get-Variable | Where {$_.Name
maiúsculas/m -cmatch “^[a-z]”}
inúsculas)

Engadir ruta set PATH=%PATH

PATH=$PATH:ruta $env:path += “;ruta”
a PATH %;ruta

Moverse polo sistema de arquivos

Comando cd (Change Directory)

Acción GNU/Linux Windows PowerShell

cd
Moverse ao
directorio cd ~ cd %userpreofile% cd $home
persoal
cd $HOME

Mostrar o
directorio pwd cd pwd
actual

Moverse ao
directorio cd / cd \ cd \
raíz

Moverse ao
directorio cd .. cd .. cd ..
anterior

unidade: unidade:
Cambiar de
unidade
cd /D unidade:ruta cd unidade:
Comandos máis usados

Acción GNU/Linux Windows

Mostrar
arquivos no
ls dir dir,ls,Get-ChildItem
directorio
actual

Mostrar
arquivos en dir
ls ruta/directorio dir,ls,Get-ChildItem ruta
calquera ruta\directorio
directorio

Mostrar
arquivos con
ls -l dir dir,ls,Get-ChildItem
tamaño,
data, etc...

Mostrar
arquivos ls -a dir /a dir -h
ocultos

ls -rt
Lista de dir /od
arquivos. O
ls -lrt dir | sort LastWriteTime
último é o
máis recente
ls -alrt

Buscar un find ruta -name dir /s

dir ruta\arquivo -recurse
arquivo arquivo ruta\arquivo

comando –help
comando /?
comando -h
Ver axuda
help comando Get-Help comando [-detail]
dun comando
man comando
(axuda de Windows)
info comando

type ruta\ficheiro
Mostrar
$fic=Get-content
ficheiro de cat ruta/ficheiro type ruta\ficheiro
ruta\ficheiro
texto
$fic

Editar un
ficheiro de
nano ruta/ficheiro edit ruta\ficheiro -
texto en
modo texto

Editar un
ficheiro de notepad
gedit ruta/ficheiro notepad ruta\ficheiro
texto en ruta\ficheiro
modo gráfico
Borrar un
rm ruta/ficheiro del ruta\ficheiro rm,del,Remove-Item
ficheiro

Borrar un
rmdir rmdir
directorio rmdir ruta\directorio
ruta/directorio ruta\directorio
(baleiro)

Borrar un
directorio
(con todo o rm -rf rmdir /s
del ruta\directorio -recurse
seu contido, ruta/directorio ruta\directorio
incluíndo
directorios)

Renomear un mv ruta/nome ren ruta\nome

ren,Rename-Item
arquivo ruta/novo ruta\novo

Renomear un mv ruta/nome move ruta\nome

ren,Rename-Item,mv
directorio ruta/novo ruta\novo

mkdir
mkdir ruta/directorio
Crear un mkdir ruta/directorio
directorio ruta/directorio
md ruta/directorio
md ruta/directorio

Mostrar algo
na pantalla
(útil para
ver
echo algo echo algo “algo”
variables de
entorno e
expansións
do shell)

copy ruta\orix copy ruta\orix ruta\dest

Copiar cp ruta/orix ruta\destcopy
ficheiro ruta/dest ruta\orix
ruta\dest Copy-Item,cp

Copiar
dicrectorio cp -r ruta/orix xcopy /e ruta\orix Copy-Item ruta\orix ruta\dest
con todo o ruta/dest ruta\dest -recurse
seu contido

comando | sls “expresion”

Filtrar comando | grep comando | find
resultados expresión “expresión”
select-string

Filtrar comando | sls “expresion”

resultados
comando | grep -i comando | find
sen ter en
expresión “expresión” Con -CaseSentitive as ten en
conta
Mai/Min conta
Caracteres comodín
Cando queremos referirnos a un conxunto de arquivos en vez de a un só, podemos usar
caracteres comodín. Tanto en Windows como en GNU/Linux:

? equivale a un carácter calquera

* equivale a un ou máis caracteres calquera

En GNU/Linux podemos usar, entre outras cousas (se distinguen maiúsculas e minúsculas):

[x-y] Unha letra dentro do rango do alfabeto entre x e y

[AaBbCcNn] Calquera dos caracteres na lista entre corchetes

Expresións regulares
En comandos como grep podemos usar expresións regulares. Entre outras moitas
posibilidades:

^ Indica principio de liña

$ indica fin de liña

Exemplo:
Filtrar as liñas que comezan por unha letra maiúscula (calquera se usamos a opción -i de grep):
^[A-Z]
Filtrar as liñas que rematan en número:
[0-9]$
Filtrar as liñas que comezan por letra e rematan en número (observa o '.' no medio):
[A-Z].[0-9]$

Máis información sobre expresións regulares: http://es.wikipedia.org/wiki/Expresi

%C3%B3n_regular

Redirección de entrada e saída

Tanto en Windows (CMD e PowerShell) como en GNU/Linux, os comandos envían e reciben
información de tres canles diferentes numeradas de 0 a 2:
0 -> Entrada estándar
1 -> Saída estándar
2 -> Saída de erros

Por defecto, os comandos escriben os erros e as mensaxes normais na pantalla (saída

estándar) e reciben información do teclado (entrada estándar).
Podemos redirixir a saída dun comando a outro usando o símbolo de canalización (|):

ls | grep meufic

Pasa a saída de ls (estándar e erros) a grep, que filtrará as liñas que non conteñan a palabra
meufic.

Podemos canalizar a saída dun comando a outro e o resultado a outro e así sucesivamente...

ls | grep ^d | grep fic

A lista de ficheiros pasa ao primeiro grep que lista as liñas que comezan por 'd' e pasa esa lista
ao segundo grep que mostra só aquelas que conteñan 'fic'.

Tamén podemos redirixir a saída dun comando a un ficheiro usando > e >>
ls > lista.txt Creará un ficheiro de nome lista.txt (borrándoo se xa existira) e gardará nel
a saída de ls (lista do contido do directorio actual).
O mesmo en Windows:
dir > lista.txt

Se queremos engadir a saída dun comando a un ficheiro existente podemos usar >> que non
borra o ficheiro senón que engade o contido ao mesmo.

ls / >> lista.txt
dir \ >> lista.txt

Engadirían o contido do directorio raíz a lista.txt.

En PowerShell convén usar Set-Content, Add-Content e Out-File para evitar problemas coa
codificación de caracteres.:

Set-Content “Lista directorio actual” lista.txt

dir | Out-file lista.txt -Append
Add-Content “Lista do directorio raíz” lista.txt
dir \ | Out-File lista.txt -Append