Está en la página 1de 47

http://sobrebits.

com/montar-un-servidor-casero-con-raspberry-pi-
parte-3-configurar-servidor-dhcp/

Objetivos e ndice.
0.Instalar Raspbian en una tarjeta SD.
1.Primera ejecucin de Raspbian.
2.Configurar servidor DHCP.
3.Configurar servidor DNS cach.
4.DNS local con actualizaciones DHCP.
5.Acceder al servidor desde el exterior.
6.Instalacin y configuracin de OpenVPN.
7.NAS con Raspberry Pi y Samba

Montar un servidor casero con Raspberry Pi


(Parte 0): Objetivos e ndice
Esta es la parte 0 de una serie de tutoriales relacionados con la
Raspberry Pi cuyo objetivo es el de montar un servidor domstico en
el que se instalarn y configurarn una serie de servicios de red con la
finalidad de aprender sobre su funcionamiento.
Son muchos los tutoriales que podemos encontrar en la red
relacionados con GNU/Linux que no son ms que una consecucin de
comandos sin explicacin alguna del por qu se ejecutan, y de nada
sirve copiar y pegar comandos en una consola como si no hubiera un
maana si al final no entendemos ni aprendemos de lo que estamos
haciendo. El concepto Raspberry Pi aparece con el objetivo de
aprender, as que intentar que aprendis algo con esta serie, y a la
vez aprender yo al redactarla.
Los requisitos necesarios para seguir estos tutoriales son:
Hardware: Un ordenador con lector de tarjetas (o un ordenador y un
lector de tarjetas), una tarjeta SD de 2GB o ms, un adaptador de
corriente para la raspi, un cable de red con el que conectar la
Raspberry al router y evidentemente una Raspberry Pi.
Software: Sistema operativo Linux o Windows en nuestro ordenador,
la imgen de Raspbian.
Conocimientos bsicos de redes y GNU/Linux para no perderse en los
conceptos explicados.
Opcionalmente se puede disponer de un cable HDMI para poder
conectar nuestro particular home server a un monitor, aunque el
tutorial se crear para ejecutar todo va SSH, es decir, a travs de la
red y por lnea de comandos.

Con todo esto y con que tengis una cuarta parte de las ganas de
aprender que tengo yo bastar.

1. Montar un servidor casero con


Raspberry Pi (Parte 1): Instalar Raspbian
en una tarjeta SD
En esta primera parte del tutorial Montar un servidor casero con
Raspberry Pi mostraremos como instalar Raspbian en una tarjeta SD
desde Linux y Windows. He elegido usar la distro Raspbian como
distribucin a usar en el tutorial ya que es una distro basada en
Debian, que para servidores no se mueve nada mal, y adems est
optimizada para el hardware de nuestras Raspberry Pi.
Para instalar dicho sistema operativo en la tarjeta SD necesitamos un
ordenador con lector de tarjetas incorporado o un lector de tarjetas
externo y evidentemente la propia tarjeta SD, de no menos de 2 GB.

OBTENIENDO LA IMAGEN DE RASPBIAN


Descargamos la ltima versin de Raspbian desde la web de
Raspberry Pi.
Es conveniente comprobar la integridad del archivo descargado
sacando su hash SHA-1. Para ello nos valdremos del
comando sha1sum. As que nos dirigimos a la ubicacin de descarga
de nuestro zip y ejecutamos:

$ sha1sum *-wheezy-raspbian.zip

Con el que deberamos obtener un resultado parecido a este:

b4375dc9d140e6e48e0406f96dead3601fac6c81 2013-02-09-wheezy-
raspbian.zip
Posteriormente compararemos el hash obtenido con el que aparece en
la seccin de descargas de la web del proyecto.
Si bien la comprobacin del hash es un paso opcional y puede parecer
innecesario, con el nos aseguraremos de que la descarga se ha
realizado correctamente y que esta no se ha visto comprometida, con
lo que nos podemos ahorrar ms de un problema.
Por ltimo descomprimimos el archivo .zip con:
$ unzip ./*wheezy-raspbian.zip

Lo que nos generar nuestra imagen .img.

PREPARANDO LA TARJETA SD PARA LA INSTALACIN


Lo siguiente que deberemos realizar es identificar nuestra tarjeta SD
en el sistema. Para ello nos valdremos del comando df, un comando
cuya finalidad es mostrar el espacio utilizado en nuestro sistema de
archivos, aunque en nuestro caso nos servir para identificar la
tarjeta SD. As que ejecutaremos:

$ df -h

Esto nos mostrar todos los puntos de montaje del sistema. Para
identificar nuestra SD tenemos dos formas de hacerlo: buscar en la
segunda columna un tamao igual al de nuestra SD o bien ejecutar el
comando sin insertar la tarjeta en nuestro ordenador y comparar esta
salida con la del mismo comando ejecutado con la SD dentro de la
ranura. Hay que tener en cuenta que es posible que nuestra SD
aparezca en ms de una entrada, esto se debe a que en la tabla se
muestran todas las particiones del dispositivo, y si nuestra SD tiene
ms de una aparecer ms de una entrada.
Una vez identificada nuestra SD deberemos fijarnos en la primera
columna, donde se muestra el nombre del sistema de ficheros, que es
la informacin que necesitamos. Nuestra informacin para la SD ser
algo como /dev/mmcblk0p1 o /dev/sdd1, hay que tener en cuenta
que p1 y 1 respectivamente, muestran la particin, as que la
informacin til que utilizaremos ser mmcblk0 o sdd.
TIP: Para realizar dicha identificacin tambin es posible usar una
herramienta grfica de particionado como puede ser Gparted.
INSTALANDO RASPBIAN EN LA TARJETA SD
Ahora que tenemos la informacin necesaria desmontaremos el
volumen (o los volmenes si tenemos ms de una particin) con el
comando umount seguido del volumen (con el nombre completo) por
cada particin montada.

$ umount /dev/mmcblk0p1

Una vez tenemos todos los preparativos hechos solo falta escribir la
imagen .img en nuestra tarjeta SD con el comando dd:

$ dd bs=4M if=./2012-12-16-wheezy-raspbian.img of=/dev/mmcblk0

En if=./2012-12-16-wheezy-raspbian.img debemos sustituir el


nombre de la imagen por la nuestra.
En of=/dev/mmcblk0 deberemos sustituir mmblk0 por nuestro
dispositivo.
Hay que tener en cuenta que este comando no ofrece ninguna salida
mientras se realiza el proceso, por lo que mientras este dure no
veremos ningn progreso, as que hay que tirar de paciencia porque el
proceso puede durar varios minutos (dependiendo bsicamente de la
velocidad de nuestra SD). Una vez haya finalizado el proceso nos
encontraremos con algo como esto:
462+1 registros ledos
462+1 registros escritos
1939865600 bytes (1,9 GB) copiados, 616,696 s, 3,1 MB/s
Que nos indicar que el proceso se ha realizado correctamente.

Hecho esto podemos ejecutar el comando $ sudo sync para


asegurarnos de que los cambios se han volcado totalmente en la SD.
Una vez llegados aqu nuestra SD estar totalmente lista para ser
desconectada e insertada dentro de nuestra Raspberry Pi para
empezar a disfrutar de ella.

INSTALAR RASPBIAN EN UNA TARJETA SD DESDE


WINDOWS

La instalacin de Raspbian en Windows es bastante trivial, es por eso


que bastan estos puntos para ser completada:

1.Descargar la ltima versin de Raspbian desde la web de Raspberry


Pi.
2.Extraer el archivo .img.
3.Comprobar la integridad del archivo comparando el hash SHA-1 con
el proporcionado por Raspberry con alguna herramienta de terceros
como esta.
4.Descargar y extraer el programa Win32DiskImager.
5.Insertar nuestra tarjeta SD y observar la letra que le asigna el
sistema.
6.Si la tarjeta no es nueva debemos asegurarnos de que slo existe
una particin en la misma, de no ser as debemos formatearla a FAT32.
7.Ejecutar Win32DiskImager.exe como administrador.
8.En Image File seleccionamos la imagen .img que hemos
descomprimido.
9.En Device seleccionamos la letra de la SD (hay que tener extrema
precaucin en este paso ya que la unidad que se seleccione ser
totalmente borrada).
Hecho esto ya podemos extraer la SD del ordenador e insertarla en la
Raspberry Pi para empezar a trastear.

En el prximo tutorial veremos el primer arranque de la Raspberry


Pi con Raspbian instalado.

Montar un servidor casero con Raspberry Pi


(Parte 2): Primera ejecucin de Raspbian
Despus de seguir los pasos de la primera parte del
tutorial deberemos conectar nuestra flamante tarjeta SD con Raspbian
instalado en su correspondiente ranura, enchufar un cable de red en
su correspondiente sitio y el cable de corriente en el puerto Micro
USB.
Nada espectacular suceder despus de esto, sabremos que el
dispositivo est encendido porque se encender una luz en el mismo.

Para acceder a nuestra Raspberry Pi sin pantalla conectada


necesitamos saber la direccin IP de esta. La forma ms fcil de
hacerlo es acceder a la pgina de configuracin de nuestro router
(habitualmente 192.168.1.1) y visualizar la tabla de DHCP. Aqu un
ejemplo:

En el ejemplo mostrado vemos que el dispositivo raspberrypi tiene


asignada la IP 192.168.1.132, as que ya tenemos los datos necesarios
para acceder a nuestra Raspberry Pi va ssh.
ACCEDER VA SSH A NUESTRA RASPBERRY PI
Aviso: Si accedes a tu Raspberry Pi con pantalla, teclado y ratn
puedes saltarte este punto.
Para acceder a nuestra Raspberry Pi utilizaremos el protocolo SSH,
que nos proporcionar una shell completa con la que interactuar con
nuestra Raspberry Pi. Gracias a l nos ahorraremos cables conectados
al dispositivo y el hipotecar un monitor para este, algo innecesario
teniendo en cuenta que no utilizaremos ningn entorno de ventanas
en ella.
Veremos el procedimiento en GNU/Linux y en Windows, en el primero
solo har falta utilizar herramientas nativas del sistema, en cambio en
Windows deberemos instalar la genial aplicacin PuTTY para realizar
la conexin.
CONEXIN SSH DESDE GNU/LINUX.
En GNU/Linux abrimos un terminal y escribimos:

$ ssh pi@192.168.1.132

El pi@ lo indicamos para conectar como el usuario por defecto que


se crea en Raspbian pi con contrasea raspberry. Si nos estamos
conectando correctamente al dispositivo recibiremos un mensaje
como este:

The authenticity of host 192.168.1.132 (192.168.1.132) cant be


established.
ECDSA key fingerprint is
XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX.
Are you sure you want to continue connecting (yes/no)?
A lo que contestaremos yes y recibiremos este mensaje:

Warning: Permanently added 192.168.1.132 (ECDSA) to the list of


known hosts.
E introduciremos la contrasea (raspberry).

Llegados aqu ya disponemos de acceso total a nuestra Raspberry Pi,


ahora toca configurar!
CONEXIN SSH DESDE WINDOWS.
Windows no ofrece nativamente un cliente ssh, por lo que hay que
recurrir a software de terceros para realizar la funcin. Por suerte el
software PuTTY viene a suplir esa carencia.
Descargamos PuTTY desde su pgina web y lo guardamos donde
queramos. El software es totalmente portable, no requiere instalacin
as que simplemente hacemos doble clic en el ejecutable y empezamos
a funcionar.

Rellenamos Host Name con la IP (en el ejemplo de este tutorial


192.168.1.132), nos aseguramos de que en el campo Puerto est
puesto el 22 y de que SSH est puesto como Connection type.

Cuando se nos pida usuario y contrasea lo llenaremos con los que se


configuran por defecto en Raspbian:

User: pi
Pass: raspberry
Llegados aqu ya disponemos de acceso total a nuestra Raspberry Pi,
ahora toca configurar!
CONFIGURAR IP FIJA EN RASPBIAN
Lo de mirar la IP desde el DHCP del router est bien para la primera
ejecucin de nuestro home server, pero a partir de ahora
necesitaremos una IP fija con la que identificar siempre el dispositivo.
La eleccin de la direccin de la IP es totalmente irrelevante, yo
elegir la 192.168.1.69 para este tutorial, pero podis usar cualquier
otra. Ms adelante se volver a cambiar esta direccin en el apartado
del servidor DHCP.

Advertencia: Es necesario utilizar una IP del mismo rango que el


actual o dejaremos aislada nuestra Raspberry Pi.

La configuracin IP se guarda en el archivo /etc/network/interfaces,


as que deberemos acudir a este para realizar la configuracin.

$ sudo nano /etc/network/interfaces

Donde nos encontraremos algo como esto:

1auto lo
2
3iface lo inet loopback
4 iface eth0 inet dhcp
5
6allow-hotplug wlan0
7 iface wlan0 inet manual
8 wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
9 iface default inet dhcp
Las dos primeras lneas hacen referencia a la interfaz loopback,
configuracin que no tocaremos.
La tercera lnea debemos comentarla con # al principio de la lnea y
debajo escribiremos algo tal que as:

1iface eth0 inet static


2 address 192.168.1.69
3 netmask 255.255.255.0
4 gateway 192.168.1.1
Cambiando estos datos por los que vayamos a usar.
La primera lnea indica que se usar una configuracin esttica y las
dems configuran dicha interfaz.

Las siguientes lneas hacen referencia a la configuracin de una


posible antena WiFi, las dejaremos tal cual.
Una vez finalizadas las modificaciones salimos con la combinacin de
teclas Ctrl+X y contestando Y cuando se nos pregunte sobre salvar
las modificaciones.

Ahora modificaremos los servidores DNS que vamos a usar, para ello
modificaremos el archivo /etc/resolv.conf.

$ sudo nano /etc/resolv.conf


Y aadimos las entradas de DNS que deseemos (la mtica 8.8.8.8 de
Google, la del router o la de tu ISP) con la sintaxis:

1nameserver 8.8.8.8
Ctrl+X, y y ya tenemos la configuracin creada, ahora falta aplicarla
reiniciando nuestra Raspberry:

$ sudo reboot

CAMBIAR LA CONTRASEA DEL USUARIO PI


Es importante no dejar las credenciales por defecto de nuestro
aparato, para hacerlo logeados como pi ejecutaremos:

$ passwd

E introduciremos los datos necesarios.

CAMBIAR LOS REPOSITORIOS DE RASPBIAN


Este apartado no es un must have dentro del tutorial, pero lo
incluyo ya que a mi los repositorios por defecto que te configura
Raspbian me iban infernalmente lentos.
Podemos consultar una lista de mirrors en la web de Raspbian y hacer
pruebas con los mirrors cercanos a nuestra localidad, que son los que
con mayor probabilidad nos irn ms rpido. En mi caso he elegido los
de Canterbury Computers.
Para configurar el repositorio elegido:

$ sudo nano /etc/apt/sources.list

Comentamos la lnea existente aadiendo # delante de esta y justo


debajo escribimos:

deb http://raspbian.canterburycomputers.com/raspbian wheezy main contrib


1
non-free rpi
Una vez modificado el archivo pulsamos la combinacin de teclas
Ctrl+X y luego Y para salvar las modificaciones.
Por ltimo actualizamos los repositorios con:

$ sudo apt-get update


ACTUALIZAR EL FIRMWARE DE LA RASPBERRY PI
Es importante mantener actualizado el Firmware de nuestra
Raspberry Pi, tenerlo actualizado nos garantiza que nuestro Hardware
va a funcionar de la mejor manera posible en la actual fecha.
Existe una herramienta creada por Hexxeh destinada a automatizar
toda la operacin, as que nos dispondremos a instalarla.
Para ello primero debemos instalar git:

$ sudo apt-get install git-core

Hecho esto descargamos la aplicacin en /usr/bin y le damos permisos


de ejecucin:

$ sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update && sudo


chmod +x /usr/bin/rpi-update

Ahora solo falta ejecutar la herramienta en si para actualizar el


firmware:

$ sudo rpi-update

Si encuentra actualizaciones del Firmware actualizar nuestro


dispositivo (tardar un rato en realizar el proceso). Para aplicar los
cambios solo debemos reiniciar la Raspberry Pi:

$ sudo reboot

ACTUALIZAR EL SOFTWARE INCLUDO EN RASPBIAN


Como en cualquier derivada de Debian:

$ sudo apt-get update

$ sudo apt-get upgrade

CONFIGURAR RASPBERRY PI
Raspbian viene provisto de un fantstico script con el que podremos
configurar cosas bsicas del sistema sin tener que calentarnos mucho
la cabeza para poder empezar rpidamente a desarrollar nuestros
proyectos con ella. Para ejecutarlo:

$ sudo raspi-config
Pasamos a detallar las opciones:

1.Info: Infromacin sobre el script.


2.Expand_rootfs: Expandir nuestra particin / hasta alcanzar el
mximo del tamao disponible en la SD. Esto solo ser necesario si
nuestra SD es de ms de 2GB, que es el tamao de la particin que se
crear al seguir los pasos de la parte 1 de este tutorial. Esta opcin
solo hay que utilizarla si no vamos a querer utilizar el resto de la
tarjeta SD para otros menesteres, como podra ser crear una particin
de datos. Cuidado: la opcin no pide confirmacin.
3.Overscan: Esta opcin sirve para habilitar o deshabilitar la funcin
overscan (# set_overscan enable/disable) en caso de que no se nos
muestre la imagen entera por la salida de nuestro monitor. Para
realizar ajustes sobre overscan podemos dirigirnos al archivo
/boot/config.txt, para ms informacin sobre la configuracin de
overscan pincha aqu.
4.Configure_keyboard: Reconfigura el teclado (# dpkg-reconfigure
keyboard-configuration) y recarga la configuracin (# invoke-rc.d
keyboard-setup start).
5.Change_pass: Cambia el password para el usuario pi ($ passwd pi).
6.Change_locale: Reconfigura la codificacin de carcteres (# dpkg-
reconfigure locales).
7.Change_timezone: Reconfigura la zona horaria del sistema (# dpkg-
reconfigure tzdata).
8.Memory_split: Con esta interesantsima opcin podemos regular que
cantidad de memoria RAM asignamos a la GPU (procesador grfico) y
el resto de esta ir a la CPU.
9.Overclock: Nos permite subir la frecuencia de nuestro procesador
para ganar rendimiento (puede causar inestabilidades en sistema).
10.Ssh: Habilita o deshabilita el servicio SSH (# update-rc.d ssh
enable/disable)
11.Boot_behaviour: Habilita o deshabilita la ejecucin de LightDM al
arrancar el dispositivo (# update-rc.d lightdm enable/disable 2), es
decir, habilita o deshabilita la ejecucin automtica del entorno
grfico.
12.Update: Esta opcin actualizar los repositorios (# apt-get update) e
intentar actualizar la herramienta raspi-config (# apt-get install
raspi-config).
De aqu descartara las opciones 1 (solo es informacin del script), 3,
4, 6(solo si nos conectamos directamente desde SSH, puesto que
estos ajustes son cogidos directamente desde la mquina desde la
que nos conectamos) y 10 y 11 (si nos conectamos va ssh querremos
tener este abierto y no necesitaremos habilitar las X para nada).
Por otro lado recomiendo ejecutar primero la opcin Update para
actualizar el script en si, y luego las dems que creamos oportunas.
Las opciones 5 y 7 son fcilmente ejecutables desde fuera del script,
pero una vez abierto este se puede aprovechar y ejecutarlas. En mi
caso la opcin de Overscan la he habilitado ya que mi SD va a ser para
uso exclusivo del sistema, pero va a gusto del consumidor.
Sobre las opciones 8 y 9 son totalmente opcionales y personales,
segn la caa que le queris meter a vuestras mquinas. Yo
particularmente el Memory_split lo tengo en 16 MB para la GPU y el
resto para la CPU ya que no voy a ejecutar ningn tipo de servidor
grfico y quiero que el chip ARM funcione como debe. El Overclock no
me he planteado subirlo an, si veo que el rendimiento de mi
Raspberry decrece lo estudiar.
Llegados aqu ya tendremos los pasos necesarios para tener nuestra
Raspberry Pi con Raspbian instalado y configurado. En el prximo
captulo pasaremos al lo y montaremos un servidor DHCP sobre
nuestra Raspberry Pi.

Montar un servidor casero con Raspberry Pi


(Parte 3): Configurar servidor DHCP
En esta tercera parte del tutorial montaremos el primer servicio en
nuestro servidor Raspbian, instalaremos un servidor DHCP en la
Raspberry Pi. Deberemos configurar en nuestra Raspberry Pi el
esquema de direcciones IP que deseamos y quitarle ese rol al router,
que es el dispositivo que actualmente est realizando esta funcin.
Para toquetear un poco ms las opciones crear un esquema de red
totalmente innecesario para una pequea red casera, pero que nos
har trastear un poco con las distintas opciones de configuracin del
servidor, lo que nos ayudar a entender mejor las posibilidades del
servicio.

ESQUEMA DE LA RED
Advertencia: Este esquema va a ser el que yo utilizar para explicar la
configuracin, podis usar el esquema que os plazca.
En vez de utilizar el rango que por defecto nuestro router trae
incorporado (192.168.1.0/24 o 192.168.0.0/24) lo cambiaremos, por
ejemplo, por 192.168.66.0/24, as si algn dispositivo queda con una
configuracin incorrecta al instante veremos que algo est pasando,
ya que quedar totalmente aislado de la red.
Reservaremos un espacio de direcciones comprendido entre la
192.168.66.100 y 192.168.66.119 donde ubicaremos
el router(192.168.66.100), la Raspberry Pi (192.168.66.101) y en mi
caso el ordenador fijo y un htpc (192.168.66.110 y 111).
El resto del espacio, 192.168.66.1-192.168.66.99 y 192.168.66.120-
192.168.66.254, ser utilizado como rango de asignacin dinmica, un
rango innecesariamente grande para una red domstica, pero que
resulta interesante de configurar.
Con esto en cuenta estos seran los datos:
Red: 192.168.66.0
Mscara de subred: 255.255.255.0
Rango DHCP: 192.168.66.1-192.168.66.99, 192.168.66.120-
192.168.66.254.
Gateway: 192.168.66.100.
Raspberry: 192.168.66.101.
Reservas DHCP: 192.168.66.110 y 192.168.66.111.
DNS: El que queramos, la ip de nuestro router, los DNS de nuestro
ISP, los de Google

INSTALACIN DEL SERVIDOR DHCP EN RASPBIAN


Para instalar el servidor DHCP deberemos conectarnos va SSH a
nuestra Raspberry Pi e instalar isc-dhcp-server con el gestor de
paquetes de Raspbian:

$ sudo apt-get install isc-dhcp-server

Al instalarlo recibiremos el siguiente aviso:


[FAIL] Starting ISC DHCP server: dhcpd[.] check syslog for
diagnostics. failed!
failed!
Esto se da porque actualmente no existe una configuracin buena
establecida, que es lo que haremos a continuacin.

CONFIGURACIN DEL SERVIDOR DHCP


Hay dos archivos de configuracin importantes que debemos conocer
a la hora de instalar nuestro servidor DHCP:

/ETC/DEFAULT/ISC-DHCP-SERVER

En este archivo podremos configurar la interfaz de red en la que


ejecutaremos el servicio. As que deberemos abrir el archivo ($ sudo
nano /etc/default/isc-dhcp-server) y buscar la lnea INTERFACES para
dejarla tal que as:

1INTERFACES=eth0

/ETC/DHCP/DHCPD.CONF

Una buena prctica antes de ponernos a modificar dicho archivo o


cualquier otro archivo de configuracin es la de hacer una copia de
seguridad del mismo, para eso:

$ sudo cp /etc/dhcp/dhcpd.conf /etc/dhcp/dhcpd.backup

Hecho esto ya estamos listos para modificar el archivo. En este


archivo reside el grueso de la configuracin, desde aqu definiremos
las opciones globales, los rangos de DHCP y sus respectivas opciones.
Para editarlo, como siempre:

$ sudo nano /etc/dhcp/dhcpd.conf

Nos encontraremos con un archivo bastante extenso aunque la


mayora comentado con # al principio de la lnea. Podemos optar por
borrar todo su contenido o bien por modificar y aadir las lneas que
nos interesan. Sea como sea, para que el servicio funcione con los
datos que hemos establecido al principio de esta entrada
necesitaremos estos datos:

1#Opciones globales
2ddns-update-style none; #Puede actualizar los registros de un DNS si la IP de
un servidor de la LAN cambia, no nos interesa.
3
option domain-name "home.local"; #Establecemos un nombre de dominio.
4
option domain-name-servers 8.8.8.8, 8.8.4.4; #Configuramos los servidores
5
DNS.
6
7
default-lease-time 259200; #Tiempo por defecto de la concesin en
8
segundos.
9
max-lease-time 604800; #Tiempo mximo de la concesin en segundos.
10
11
authoritative; #Establece el servidor como principal.
12
log-facility local7;
13
14
#Opciones de subred
15
subnet 192.168.66.0 netmask 255.255.255.0 { #Declaracin de la subred.
16
range 192.168.66.1 192.168.66.99; #Primer rango de direcciones.
17
range 192.168.66.120 192.168.66.254; #Segundo rango de direcciones.
18
option routers 192.168.66.100; #Gateway (nuestro router).
19
option subnet-mask 255.255.255.0; #Mscara de subred.
20
option broadcast-address 192.168.66.255; #Direccin de broadcast
21
}
22
23
#Reserva de direcciones
24
host timbleck-pc1 { #Declaramos la reserva
25
hardware ethernet 00:11:22:33:44:55; #Direccin MAC del dispositivo.
26
fixed-address 192.168.66.110; #Direccin IP reservada.
27
}
28
29
#Reserva de direcciones
30
host timbleck-pc2 { #Declaramos la reserva
31
hardware ethernet 00:00:00:11:11:11; #Direccin MAC del dispositivo.
32
fixed-address 192.168.66.110; #Direccin IP reservada.
}
Es importante respetar la sintaxis del archivo (sobretodo sus ; ya
que son fciles de olvidar).

Si bien he intentado comentar cada lnea para que se entienda su


significado paso a explicar la estructura del archivo. El archivo consta
de tres partes en este ejemplo:

Opciones globales: La primera parte del archivo, aqu se declaran las


opciones que sern comunes para todas las subredes que
configuremos en el servidor.
Opciones de subred: Son opciones que slo son vlidas para dicha
subred.
Reserva de direcciones: Asociamos direcciones MAC a direcciones IP,
cuando estas se conectan en vez de darles una IP de alguno de los
rangos configurados les dar la que hayamos configurado
manualmente.
EVITANDO EL DESASTRE INMINENTE
Con todo esto configurado estamos a un comando del desastre: en el
momento en el que activemos el servicio de DHCP el servidor va a
empezar a asignar IPs de un rango cuyo gateway no existe, adems
de ser un rango distinto al de su propia IP, as que perderemos la
conectividad hacia Internet y hacia nuestro servidor DHCP.

Para ahorrarnos el tener que configurar las IPs a mano vamos a hacer
las cosas en el orden correcto.
El primer paso va a ser cambiar la IP interna de nuestro router y
asignarle la que hemos convenido, as que nos conectamos a su
servidor web y le configuramos la IP 192.168.66.100.
Adems, deberemos desactivar el servicio de DHCP del mismo desde
su panel de control.
Lo siguiente ser cambiar la IP de nuestra Raspberry Pi. Lo haremos
como en el tutorial anterior, es decir, editando el
archivo /etc/network/interfaces:

1iface eth0 inet static


2address 192.168.66.101
3netmask 255.255.255.0
4gateway 192.168.66.100

Y reiniciando el dispositivo. Al reiniciar el dispositivo la Raspberry


volver a intentar levantar el servicio, y esta vez debera hacerlo con
xito puesto que todas las opciones han sido correctamente
configuradas.
Ahora nos toca volver a solicitar una IP va DHCP en los distintos
dispositivos de la red. Para hacerlo podemos reconectar la red
fsicamente o bien:

En Linux: Escribimos en un terminal: $ sudo dhclient -r.


En Windows: Escribir en un terminal: ipconfig /release, y luego,
ipconfig /renew.
Con todo esto hecho ya deberamos estar funcionando con nuestro
nuevo esquema de red en la nueva subred 192.168.66.0/24 sin que los
dispositivos que a partir de ahora se conecten noten el cambio.
Advertencia: Si dispones un ordenador con *buntu o derivadas (a
partir de la versin 12.04) y la configuracin de DNS no se te actualiza
(apuntando siempre a 127.0.0.1 o 127.0.1.1) lee esto.
Cambiar DNS en Ubuntu 12.04 y posteriores
En *buntu y derivadas a partir de la versin 12.04 si intentamos
realizar cambios sobre nuestra configuracin DNS veremos como
estos se revierten al cabo del rato asignndonos siempre un
DNS: 127.0.0.1 (para 12.04 y derivadas) o 127.0.1.1 (para 12.10 y
derivadas).

POR QU NO PODEMOS CAMBIAR DNS EN UBUNTU Y DERIVADAS?


Esto no es un error, eso es evidente, ya que podemos navegar
perfectamente, por lo tanto ah abajo hay algo resolviendo nombres.
Se trata de dnsmasq (un servidor DNS ligero) gestionado por Network
Manager (el gestor de conexiones que incorpora la distribucin). Es
por ese motivo que nuestra configuracin DNS apuntar a nuestra
propia mquina, porque nosotros mismos estamos resolviendo
nombres.
Esto est bien, para el usuario domstico no debera tener mayor
inconveniente, de hecho esta funcin se implement para mejorar las
velocidades en la resolucin de nombres de las conexiones VPN,
puesto que se ahorra trfico por dicho canal, que puede ser de
reducido ancho de banda.
El problema viene cuando en nuestra red local existe un servidor DNS
que queremos/debemos usar, como el del tutorial de Raspberry Pi.
Network Manager sobreescribir automticamente la configuracin
DNS asignada por DHCP o manualmente por las mencionadas
anteriormente 127.0.0.1 y 127.0.1.1.
Si queremos utilizar otro servidor DNS antes deberemos hacer que
Network Manager siga usando el suyo propio.

DESHABILITAR DNSMASQ EN NETWORK MANAGER


Despus del tocho terico vamos a la parte prctica, que es muy
sencilla. Para cambiar el DNS en Ubuntu 12.04 y posteriores debemos
editar el archivo de configuracin de Network Manager:

$ sudo nano /etc/NetworkManager/NetworkManager.conf

Y comentar la lnea correspondiente:

1# dns=dnsmasq
Ctrl + O para salvar cambios y Ctrl + X para salir.
Con esto solo nos queda reiniciar el PC o bien hacer lo propio con
Network Manager:

$ sudo restart network-manager


Hecho esto nuestro sistema empezar a recibir los DNS de la forma
habitual, como cualquier otro sistema GNU/Linux.

Montar un servidor casero con Raspberry Pi


(Parte 4): Configurar servidor DNS cach
En este cuarto episodio del tutorial aprenderemos a instalar y
configurar nuestro propio servidor DNS cach en la Raspberry Pi, con
el objetivo de mejorar la velocidad de navegacin de los dispositivos
de nuestra LAN.
Nuestro servidor guardar las consultas DNS realizadas durante un
periodo de tiempo, as aquellas consultas repetidas en dicho periodo
sern mucho ms rpidas ya que no llegarn a salir de nuestra propia
LAN.

INSTALAR SERVIDOR DNS EN RASPBIAN


Para instalar nuestro servidor DNS en la Raspberry Pi tiraremos, como
no, de nuestro querido gestor de paquetes, as que:

$ sudo apt-get install bind9 bind9-doc dnsutils

Como podemos ver adicionalmente hemos instalado dnsutils, que


contiene una herramienta a la que posteriormente le daremos uso.

CONFIGURAR SERVIDOR DNS CACH


Una vez instalado el servicio de DNS procederemos a configurarlo
para que realice las funciones que precisamos. Para ello no est de
ms conocer los distintos archivos de configuracin de BIND9:

/etc/bind/named.conf: Es el archivo de configuracin principal de


BIND9, se encarga de cargar tres archivos de configuracin y
centralizarlos.
/etc/bind/named.conf.options: Desde aqu podemos configurar las
opciones generales del servicio, el directorio de trabajo, los
forwarders, etc. Este es el archivo que tocaremos en esta parte del
tutorial.
/etc/bind/named.conf.local: En este archivo podemos configurar las
zonas locales del servidor DNS, esto es, configurar dominios que en
vez de buscarse fuera mediante los forwarders se buscarn en el
propio servidor DNS. Este archivo se utilizar en posteriores
tutoriales.
/etc/bind/named.conf.default.zones: Donde podemos configurar las
zonas por defecto del servidor. En futuros tutoriales se tocar este
archivo.
La configuracin por defecto despus de la instalacin de bind9 nos
proporciona un servidor DNS cach listo para ser utilizado sin ms
problema, pero eso no es muy divertido que digamos, as que vamos a
trastear un poco con los archivos de configuracin para ver qu
posibilidades tenemos.

Para nuestro servidor DNS cach necesitamos configurar solo el


archivo named.conf.options, as que:

$ sudo nano /etc/bind/named.conf.options

Por defecto vienen algunas configuraciones as como una serie de


advertencias en los comentarios.
Deberemos dejar el archivo as:
options {
1
2
directory /var/cache/bind; # Directorio donde se almacenar la cach.
3
4
auth-nxdomain no; # conform to RFC1035
5
6
# Reenviadores
7
forwarders { # Reenviamos las consultas a:
8
8.8.8.8; # DNS de Google.
9
8.8.8.4; # DNS de Google.
10
192.168.66.100; # IP del router.
11
};
12
13
# Opciones de seguridad
14
listen-on port 53 { # Escuchamos en el puerto 53 (Puerto por defecto)...
15
127.0.0.1; # ... por la interfaz de loopback...
16
192.168.66.101; # ... y por nuestra IP de red.
17
};
18
19
listen-on-v6 { none; }; # No escuchamos trfico IPv6
20
21
allow-query { # Permitimos consultas DNS desde...
22
127.0.0.1; # ... la interfaz de loopback...
23
192.168.66.0/24; # ... y nuestra red interna.
24
};
25
26
allow-transfer { none; }; # Prohibimos la transferencia de zonas puesto que
27
este es nuestro nico servidor DNS de la LAN
28
29
allow-recursion { # Permitimos consultas recursivas desde...
30
127.0.0.1; # ... la interfaz de loopback...
31
192.168.1.0/24; # ... y la red interna.
32
};
33
34
};
Con esto tendremos el grueso de la configuracin hecho, as que
pasamos a comprobar que esta es correcta:

$ sudo named-checkconf

Si el comando no arroja ninguna salida indica que no se han


encontrado errores, as que podemos continuar.

Despus de esto reiniciaremos el servicio DNS con:

$ sudo /etc/init.d/bind9 restart

Hecho esto ya tenemos nuestro servidor DNS cach funcionando en


nuestra Raspberry Pi.
CONFIGURAR LOS CLIENTES CON EL NUEVO SERVIDOR DNS CACH
La configuracin del servidor est hecha, el siguiente paso es que los
clientes (incluido nuestro servidor), hagan las consultas DNS a
nuestro servidor DNS cach en la Raspberry Pi.

Para cambiar el DNS de nuestra Raspberry Pi debemos realizar lo


mismo que en el segundo tutorial, es decir, dirigirnos a
/etc/resolv.conf y configurar el servidor DNS:

$ sudo nano /etc/resolv.conf

Borramos el contenido y aadimos:

1nameserver 127.0.0.1
Con esto hecho nuestra Raspberry Pi est consultando a su propio
servidor DNS las direcciones.

Para que los dems clientes de la red resuelvan nombres va nuestro


nuevo servidor DNS cach debemos acudir a lo explicado en
el anterior tutorial y cambiar la configuracin del archivo
/etc/dhcp/dhcpd.conf y modificar el campo domain-name servers as:
1option domain-name-servers 192.168.66.101;
Posteriormente reiniciamos el servicio dhcp con:

$ sudo /etc/init.d/isc-dhcp-server restart

Y reiniciamos los clientes dhcp de los ordenadores clientes.

COMPROBANDO EL FUNCIONAMIENTO DEL SERVIDOR DNS CACH


Para comprobar que est funcionando podemos valernos de la
herramienta dig, contenida en el paquete dnsutils, que nos indicar el
tiempo de resolucin del nombre. Para ello hacemos una primera
consulta:

timbleck@mint ~ $ dig raspberrypi.org | grep


1
Query
2
;; Query time: 68 msec
Que nos dar un tiempo en milisegundos elevado. Si volvemos a
hacerlo con el mismo dominio:

timbleck@mint ~ $ dig raspberrypi.org | grep


1
Query
2
;; Query time: 3 msec
Obtenemos un tiempo de respuesta MUY inferior gracias a que la
Raspberry Pi no necesita volver a consultar al DNS de Google la
informacin, ya que esta est contenida en la cach del servidor.

OBSERVACIONES FINALES
Haciendo pruebas bajo la misma lnea entre la comparacin de
velocidad de resolucin de nombres apuntando directamente a los
DNS de Google y apuntando a la Raspberry Pi nos encontraremos con
los siguientes datos:
Los tiempos de respuesta para la primera consulta sobre un dominio
apuntando directo al DNS de Google o apuntando a la Raspberry
Pi son muy similares, con variaciones de pocos ms entre un sistema y
el otro. En cambio en la segunda consulta podemos observar como el
tiempo consultando directamente al DNS de Google es el mismo que
en la primera ocasin pero en la Raspberry Pi la resolucin es casi
inmediata.
As que podemos decir tranquilamente que despus de la
implementacin hemos ganado en velocidad de navegacin gracias a
nuestra Raspberry Pi.
Advertencia: Si dispones un ordenador con *buntu o derivadas (a
partir de la versin 12.04) y la configuracin de DNS no se te actualiza
(apuntando siempre a 127.0.0.1 o 127.0.1.1) lee punto Cambiar DNS
en Ubuntu 12.04 y posteriores.

Montar un servidor casero con Raspberry Pi


(Parte 5): DNS local con actualizaciones
dinmicas DHCP
Despus de configurar nuestro servidor DHCP y nuestro servidor DNS
cach toca darle una vuelta de tuerca a nuestro servidor Raspberry Pi
y aprovechar las capacidades de DHCP junto a las de DNS para crear
un servidor DNS local que actualice automticamente los registros
para las direcciones concedidas por DHCP.

SERVIDOR DNS LOCAL CON ACTUALIZACIONES DHCP


Antes de ponernos manos a la obra es necesario entender que implica
tener un servidor DNS local con actualizaciones DHCP. Esto es, cada
vez que el servidor DHCP conceda una direccin IP a un dispositivo se
dirigir al servidor DNS y crear/actualizar el registro
correspondiente a dicho dispositivo. Con eso conseguimos poder
acceder a recursos compartidos en la red sin la necesidad de
memorizar las direcciones IP completas, solo necesitamos recordar el
nombre, cosa mucho ms amigable.

Dicho esto podemos proceder a la configuracin.

ASEGURANDO LAS COMUNICACIONES


Por razones de seguridad no podemos permitir que cualquier
dispositivo actualice registros DNS, ya que esto podra suponer una
infinidad distinta de ataques contra nuestra infraestructura. Si bien
este servidor Raspberry Pi est ubicado en un domicilio nunca est de
ms intentar aplicar algunas medidas.
Para aportar seguridad a las comunicaciones entre DHCP y Bind
generaremos una clave compartida que ser usada para la
actualizacin de registros:

$ sudo /usr/sbin/rndc-confgen -a

Esto nos generar un archivo /etc/bind/rndc.key. Esta clave deber ser


configurada tanto en el servidor DNS como en el DHCP para que las
comunicaciones se realicen correctamente.

CONFIGURACIN DE ZONAS DNS


Ahora toca configurar la zona de resolucin directa e inversa para
nuestro dominio. En el tutorial DHCP este era home.local, as que ese
ser el nombre que le daremos al dominio. El archivo de configuracin
de zonas locales se encuentra en /etc/bind/named.conf.local. As que:

$ sudo nano /etc/bind/named.conf.local

Y deberemos configurar el archivo as:

include "/etc/bind/rndc.key"; # Inclumos la clave compartida al archivo


1
2zone home.local { # Zona de resolucin directa
3 type master; # Generamos respuestas autoritativas
4 file "/var/lib/bind/home.local"; # Archivo de zona
5
allow-update { key rndc-key; }; # Permitimos actualizaciones solo con la
6
clave compartida
7
};
8
9
zone 66.168.192.in-addr.arpa { # Zona de resolucin inversa
10
type master;
11
file "/var/lib/bind/66.168.192";
12
13 allow-update { key rndc-key; };
};
Hecho esto podemos asegurarnos de que la configuracin es correcta
con:

$ sudo named-checkconf

Que no debera darnos salida alguna, indicando que no hay errores en


la configuracin.
En este punto tenemos las zonas declaradas, pero necesitamos
configurarlas. Lo siguiente ser editar los archivos de zona
establecidos anteriormente, empezamos con home.local:

$ sudo nano /var/lib/bind/home.local

Deberemos dejar el archivo as:

# Definimos que el dominio cuelga directamente del dominio ., root.


1$ORIGIN .
2# Time-to-live del servicio.
3$TTL 604800
4
5# Definimos el Start Of Authority, el serial para seguir los eventos
6relacionados con la zona
7# y los registros de intervalo.
8home.local IN SOA raspberry.home.local. webmaster.home.local. (
9 1353527646 ; serial
10 10800 ; refresh
11 3600 ; retry
12
604800 ; expire
13
38400 ; minimum
14
)
15
16;
17
18# Definimos el registro Name Server para el dominio.
19 NS raspberry
20# Y su IP asociada.
21 A 192.168.66.101
22;
23
24# Definimos el origen en nuestro dominio.
25$ORIGIN home.local
26
27# Aqu definiremos los registros fijos, en nuestro caso nuestro servidor.
raspberry A 192.168.66.101
Finalizada la configuracin la comprobamos con:

$ sudo named-checkzone home.local /var/lib/bind/home.local


A lo que deberamos recibir:

zone home.local/IN: loaded serial


1
1353527646
2
OK
Ahora toca hacer lo mismo para la zona de resolucin inversa:

$ sudo nano /var/lib/bind/66.168.192

Y dejaremos la configuracin as:

$ORIGIN .
1$TTL 604800
2
366.168.192.in-addr.arpa IN SOA raspberry.home.local.
4webmaster.home.local. (
5 1353527647 ; serial
6 10800 ; refresh
7
3600 ; retry
8
604800 ; expire
9
38400 ; minimum
10
11 )
12
13NS raspberry.home.local.
14
15$ORIGIN 66.168.192.in-addr.arpa.
101 PTR raspberry.home.local.
Comprobamos la configuracin con:

$ sudo named-checkzone 66.168.192.in-addr.arpa


/var/lib/bind/66.168.192

Vamos a comprobar que las zonas configuradas estn funcionando


reiniciando el servicio bind:

$ sudo /etc/init.d/bind9 restart

Ahora nuestro DNS local est funcionando, para comprobarlo nos


valdremos de la herramienta nslookup para comprobar la resolucin
directa e inversa:

$ nslookup

Para la resolucin directa:

> raspberry.home.local
Que nos mostrar su direccin IP.
Ahora la resolucin inversa:

> 192.168.66.101

Que nos mostrar el campo name junto con el nombre de red del
dispositivo.
Si las pruebas son satisfactorias querr decir que nuestro dominio
est montado.

CONFIGURAR DHCP PARA REALIZAR ACTUALIZACIONES DNS


Aqu viene lo realmente interesante del caso, y es que montar un
servidor DNS local para simplemente relacionar una IP con el nombre
de un servidor es como poco matar moscas a caonazos, ahora bien, si
podemos hacer lo mismo con todos los dispositivos de nuestra red
local sin tener que modificar registros a mano cada vez que estos
cambian de direccin IP la cosa se vuelve bastante curiosa.

Para conseguir que DHCP actualice registros DNS necesitamos editar


la configuracin que vimos el tutorial sobre DHCP. As que vamos a
ello:

$ sudo nano /etc/dhcp/dhcpd.conf

Buscamos el campo ddns-update-style configurado anteriormente, lo


borramos y escribimos lo siguiente:
ddns-updates on; # Activamos la funcin de Dynamic DNS
1
ddns-update-style interim; # Mtodo de actualizacin dinmica
2
update-static-leases on; # Actualizamos tambin los registros con reserva
3
DHCP
4
include "/etc/bind/rndc.key"; # Inclumos la clave compartida
5
6
ddns-domainname "home.local."; # Nombre de dominio ddns
7
ddns-rev-domainname "in-addr.arpa."; # Nombre de dominio ddns inverso
COMPROBANDO LAS ACTUALIZACIONES DNS VA DHCP
Hasta aqu la parte de configuracin del servidor, ahora solo nos falta
cruzar los dedos mientras comprobamos que todo funciona
correctamente.
Para ello lo primero ser reiniciar ambos servicios:

$ sudo /etc/init.d/bind9 restart

$ sudo /etc/init.d/isc-dhcp-server restart


Ahora abriremos el log del sistema para ver qu pasa cuando
conectamos un cliente va DHCP.

$ tail -f /var/log/syslog

Con esto en pantalla podemos proceder a conectar un nuevo cliente a


la red. Automticamente debera aparecer algo parecido a esto en
nuestro log:

May 5 20:14:04 raspberrypi named[6586]: client 127.0.0.1#39456: signer


"rndc-key" approved
May 5 20:14:04 raspberrypi named[6586]: client 127.0.0.1#39456: updating
zone 'home.local/IN': adding an RR at 'HTPC.home.local' A
May 5 20:14:04 raspberrypi named[6586]: client 127.0.0.1#39456: updating
zone 'home.local/IN': adding an RR at 'HTPC.home.local' TXT
May 5 20:14:05 raspberrypi dhcpd: DHCPREQUEST for 192.168.66.6 from
AA:BB:CC:DD:EE:FF (HTPC) via eth0
May 5 20:14:05 raspberrypi dhcpd: DHCPACK on 192.168.66.6 to
1AA:BB:CC:DD:EE:FF (HTPC) via eth0
2May 5 20:14:06 raspberrypi dhcpd: Added new forward map from
3HTPC.home.local. to 192.168.66.6
4May 5 20:14:06 raspberrypi named[6586]: zone home.local/IN: sending
5notifies (serial 1353527647)
6May 5 20:14:06 raspberrypi named[6586]: client 127.0.0.1#39456: signer
7"rndc-key" approved
8May 5 20:14:06 raspberrypi named[6586]: client 127.0.0.1#39456: updating
9zone '66.168.192.in-addr.arpa/IN': deleting rrset at '6.66.168.192.in-
10addr.arpa' PTR
11May 5 20:14:06 raspberrypi named[6586]: client 127.0.0.1#39456: updating
12zone '66.168.192.in-addr.arpa/IN': adding an RR at '6.66.168.192.in-
13addr.arpa' PTR
14May 5 20:14:10 raspberrypi dhcpd: Added reverse map from
6.66.168.192.in-addr.arpa. to HTPC.home.local.
May 5 20:14:10 raspberrypi named[6586]: client 127.0.0.1#39456: signer
"rndc-key" approved
May 5 20:14:10 raspberrypi named[6586]: client 127.0.0.1#39456: updating
zone '66.168.192.in-addr.arpa/IN': deleting rrset at '6.66.168.192.in-
addr.arpa' PTR
May 5 20:14:10 raspberrypi named[6586]: client 127.0.0.1#39456: updating
zone '66.168.192.in-addr.arpa/IN': adding an RR at '6.66.168.192.in-
addr.arpa' PTR
Si prestamos atencin al log podemos ver como hay dos grupos de
registros, los procedentes de dhcpd y los procedentes named.
Tambin podemos observar el uso de la clave compartida as como de
la comunicacin entre un servicio y el otro.
As que a partir de ahora, para referirnos a cualquier dispositivo de la
red bastar con usar su nombre, esto es, para conectarnos a la
Raspberry Pi va ssh ahora podemos utilizar:

$ ssh pi@raspberry.home.local
Hasta aqu todo lo relacionado con DHCP y DNS en este tutorial.

Advertencia: Si dispones un ordenador con *buntu o derivadas (a


partir de la versin 12.04) y la configuracin de DNS no se te actualiza
(apuntando siempre a 127.0.0.1 o 127.0.1.1) lee (Punto de cambio
DNS Ubuntu 12.04 y posteriores).

Montar un servidor casero con Raspberry Pi


(Parte 6): Acceder al servidor desde el exterior
En esta parte 6 del tutorial veremos como acceder al servidor desde el
exterior de la red local de nuestro domicilio. Obtendremos un dominio
personalizado con el que acceder a nuestra red e intentaremos
aportar un poco de seguridad al sistema.

CONFIGURACIN DE DNS DINMICO CON NO-IP


Esta serie de tutoriales se centra en la creacin de un servidor
domstico con nuestra Raspberry Pi, y puesto que lo ms habitual en
nuestros hogares es disponer de una conexin con IP dinmica
deberemos conseguir una forma amigable de conectarnos desde el
exterior, ya que la IP que te puedas apuntar hoy puede que no te sirva
maana.

Hay multitud de servicios orientados a solucionar este problema, uno


de los ms utilizados es el de no-ip que ser el que utilizaremos aqu.
Lo primero que debemos hacer es registrarnos en su website y crear
un nuevo hostname del tipo A con un nombre que podamos recordar
y asignando el dominio que prefiramos de la lista. No voy a detallar el
proceso ya que existen multitud de tutoriales al respecto en la red.
Hecho esto tenemos nuestro nombre de dominio creado, pero
necesitamos asociarlo a nuestra red, y adems hacer que nuestra
Raspberry Pi actualice ese registro cada cierto intervalo de
tiempo para que, cuando nuestra direccin IP pblica cambie, el
hostname de no-ip se actualice.
Para ello debemos seguir los siguientes pasos extrados de su web:
Nos dirigimos al directorio desde el que instalaremos el programa:

$ cd /usr/local/src

Descargamos el programa:
$ sudo wget http://www.no-ip.com/client/linux/noip-duc-
linux.tar.gz

Lo descomprimimos e instalamos:

$ sudo tar -xvzf noip-duc-linux.tar.gz

$ cd no-ip-2.1.9-1

$ sudo make

$ sudo make install

Aqu se nos generar el archivo de configuracin por


defecto /usr/local/etc/no-ip2.conf con los datos que se nos
preguntarn:
Please enter the login/email string for no-ip.com
1
Please enter the password for user 'sdasd@asdsad.com'
2
3
Only one host [dfsf.no-ip.com] is registered to this
4
account.
5
It will be used.
6
Please enter an update interval:[30]
Los rellenamos y ya tendremos todo listo. Ahora con ejecutar el
archivo /usr/local/bin/noip2 se nos actualizar el registro hostname en
no-ip cada X intervalo que hayamos configurado.
Lo ltimo que deberemos hacer ser crear un simple script que
se ejecute tras cada reinicio para que llame a este ejecutable.
En el directorio /usr/local/src/noip-2.1.9-1 se nos proporciona
informacin sobre cmo hacerlo en perfecto castellano en el
archivo LEEME.PRIMERO debajo del apartado COMO INICIAR EL
CLIENTE.
As que procederemos a crear el archivo en init.d:

$ sudo nano /etc/init.d/noip2

Y copiamos el siguiente contenido dentro:


##############################################
1####################
2#!/bin/sh
3#./etc/rc.d/init.d/functions #descomente/modifique para su killproc
4case "$1" in
5start)
6echo "Iniciando noip2..."
7/usr/local/bin/noip2
8;;
9stop)
10echo -n "Apagando noip2..."
11killproc -TERM /usr/local/bin/noip2
12;;
13*)
14echo "Uso: $0 {start|stop}"
15exit 1
16esac
17exit 0
18##############################################
###################
Guardamos y procedemos a darle permisos de ejecucin al script as
como actualizar la configuracin de arranque con este script:

$ sudo chmod 755 /etc/init.d/noip2

$ sudo update-rc.d noip2 defaults

Podemos reiniciar la Raspberry Pi para comprobar que efectivamente


se ejecuta el script.

AADIENDO SEGURIDAD A RASPBERRY PI


Tenemos que ser muy conscientes de lo que estamos haciendo,
estamos abrindonos la puerta de entrada al dispositivo desde el
exterior de nuestra red local, por lo que los riesgos de seguridad se
disparan. Hay algunas medidas de seguridad que podemos aplicar
para conseguir un plus de seguridad en el dispositivo. Estas medidas
no son infranqueables, nada en el mundo de la informtica lo es, pero
podemos intentar protegernos de los ataques ms frecuentes.

SEGURIDAD EN LOS USUARIOS


Este es el primero de todos los pasos. Hay que ser consciente que si
no disponemos de una contrasea robusta para nuestros usuarios
estamos dejando la puerta abierta a nuestro sistema, cosa que no
queremos. Hay mucha documentacin sobre creacin de contraseas
seguras en la red, un buen punto para empezar es este
(http://eduteka.icesi.edu.co/articulos/ContrasenhasRobustas).
Una vez hemos determinado la contrasea que queremos usar
podemos actualizarla con un simple:

$ passwd

Tampoco est de ms cambiar el nombre del usuario pi por otro, o


crear uno nuevo y eliminar este, ya que cuantas menos cosas
tengamos en nuestro sistema por defecto ms difcil estamos
ponindole las cosas a un atacante. Podemos consultar esta gua de
referencia (http://www.linuxtotal.com.mx/index.php?cont=info_admon_008) para la
gestin de usuarios.

SEGURIDAD EN SSH
El primer servicio al que probablemente queremos acceder una vez
abierta la comunicacin con el exterior es a ssh, para as poder
acceder a nuestro dispositivo desde donde queramos. Como este
servicio provee acceso completo a nuestro sistema deberemos realizar
algunas tareas para asegurar el servicio. Podemos acceder a su
archivo de configuracin desde:

$ sudo /etc/ssh/sshd_config

Hay muchas cosas que nos puede interesar cambiar en este archivo,
pero bsicamente tocaremos dos. Cambiaremos el puerto por defecto
ya que como anteriormente he dicho hay que huir de las
configuraciones por defecto. As que nos dirigimos al campo Port y
cambiamos el 22 por el que nos plazca:

1Port 6784
Por otro lado prohibiremos al usuario root la conexin ya que en el
supuesto caso de que se consiguiera acceso con este usuario por un
atacante estaramos totalmente vendidos. As que nos dirigimos a
PermitRootLogin y cambiamos el yes por no.

1PermitRootLogin no
Estas son medidas bsicas, con una rpida bsqueda en la red
encontraremos muchas ms medidas a tomar para endurecer el
servicio.

Recordad que a partir de ahora para conectaros va ssh a la Raspberry


Pi habr que especificar el puerto, ya sea rellenando el campo
correspondiente en PuTTY o con la opcin -p en GNU/Linux:
$ ssh pi@raspberry.home.local -p 6784

EVITAR ATAQUES DE FUERZA BRUTA CON FAIL2BAN


Fail2ban es una fantstica aplicacin que monitoriza los logs de los
principales servicios a instalar en un servidor en busca de intentos
fallidos de login. Al detectarse una cantidad X de intentos
(configurable) desde una misma IP se procede a bloquear el acceso
durante Y tiempo (configurable tambin.
Para instalarlo, como siempre:

$ sudo apt-get install fail2ban

Fail2ban viene con una serie de servicios ya configurados, facilitando


extremadamente su puesta en marcha.

Su archivo de configuracin se encuentra en /etc/fail2ban/jail.conf. As


que como siempre creamos una copia de backup del archivo y
procedemos a editar:

$ sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.conf.back

$ sudo nano /etc/fail2ban/jail.conf

Hay muchas cosas que podemos configurar aqu, nosotros solo


veremos unas pocas.
En la seccin [DEFAULT] encontramos las opciones:
ignoreip = 127.0.0.1/8 # IPs a ignorar. Podemos aadir el rango local con
1
192.168.66.0/24.
2
bantime = 172800 # Tiempo en segundos del bloqueo.
3
maxretry = 5 # Cantidad de intentos fallidos permitidos.
Estas son las opciones generales, ahora podemos dirigirnos a la
seccin JAILS donde encontraremos [ssh]. Nos aparecer una
configuracin por defecto preparada para funcionar con ssh y que
modificaremos para cumplir con nuestros intereses:
enabled = true # Indicaremos que empiece a filtrar ssh.
1
port = 6784 # Aqu pondremos el puerto configurado
2
anteriormente.
El resto de la configuracin lo dejaremos tal cual, aunque podemos
cambiar el nmero que aparece en maxretry ya que este
sobreescribir la configuracin del apartado [DEFAULT].

Hecho esto reiniciamos el servicio con:

$ sudo service fail2ban restart


NOTAS FINALES
Hecho esto debemos redirigir el puerto 6784 en nuestro router
apuntando a nuestro servidor Raspberry Pi.
Hay que tener en cuenta que estas medidas no nos protegern ante
todo lo que acecha al otro lado de nuestro router, pero s que
evitaremos caer ante ataques automatizados de fuerza bruta, que al
final son los ms fciles de llevar a cabo, incluso por gente que no
necesariamente sepa mucho de seguridad informtica.
Es interesante ir revisando peridicamente los logs del sistema,
situados en /var/log/ para detectar posibles intrusiones a nuestro
sistema.

Montar un servidor casero con Raspberry Pi


(Parte 7): Instalacin y configuracin de
OpenVPN
En esta sptima parte del tutorial veremos cmo instalar y configurar
un servidor OpenVPN en Raspbian (y por consiguiente en Debian
Wheezy). Crearemos una autoridad certificadora y generaremos
nuestros certificados de servidor y cliente para autenticar y cifrar el
contenido de nuestras comunicaciones.

POR QU QUEREMOS INSTALAR UN SERVIDOR OPENVPN EN


RASPBIAN?
Tener un servidor OpenVPN domstico nos ofrecer dos
funcionalidades la mar de interesantes:

Anonimizar conexiones.
Acceder a recursos internos de nuestra red local desde el exterior.
El primer punto es algo bsico si decidimos conectar nuestros
dispositivos a una red pblica. Desde que capturar trfico en una red
es algo tan trivial como tener la aplicacin indicada en nuestro
telfono mvil el navegar desde cualquier red abierta sin ningn tipo
de proteccin por nuestra parte es cuanto menos temerario. El
segundo punto es una funcionalidad la mar de interesante si
disponemos de algn tipo de almacenamiento compartido en la red
desde el que queramos acceder desde cualquier lado.
Una vez visto lo que nos puede aportar este nuevo servicio de nuestra
Raspberry Pi vamos a instalarlo y configurarlo.
CREAR UNA AUTORIDAD CERTIFICADORA Y GENERAR CERTIFICADOS
CON EASY-RSA
OpenVPN se basa en OpenSSL para implementar la criptografa
SSL/TLS. Para ello tenemos dos opciones:
1.Configurar una clave privada compartida.
2.Configurar un certificado con el estndar X.509 basado en
infraestructura de llave pblica.
Para este tutorial utilizaremos la segunda opcin, aprovechando que
OpenVPN incorpora todo lo necesario para hacerlo.

Antes que nada deberemos proceder a instalar OpenVPN en Raspbian:

$ sudo apt-get install openvpn

Despus de la instalacin, si nos dirigimos a la


carpeta /usr/share/doc/openvpn/examples encontraremos distintas
carpetas con ejemplos de configuracin, claves, scripts y lo que ahora
nos ocupa, con la carpeta easy-rsa, que nos ayudar a crear nuestra
propia autoridad certificadora con RSA.
As que procederemos a copiar esta carpeta de ejemplo a la ubicacin
que queramos para trabajar con ella:

$ sudo cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0
/etc/openvpn/

Y nos dirigimos a su nueva ubicacin:

$ cd /etc/openvpn/2.0

El siguiente paso ser editar el archivo vars llenndolo con nuestra


informacin. As que lo abrimos:

$ sudo nano /etc/openvpn/2.0/vars

Y rellenamos con nuestros datos. Aqu va un ejemplo:

1export KEY_COUNTRY="ES"
2export KEY_PROVINCE="BARCELONA"
3export KEY_CITY="Barcelona"
4export KEY_ORG="Sobrebits"
5export KEY_EMAIL="micorreo@micorreo.com"
6export KEY_CN=micommonname
7export KEY_NAME=minombredeclave
8export KEY_OU=IT
Despus de esto ya estamos listos para exportar los datos del archivo
vars.

$ sudo su

# source vars

Podemos comprobar que las variables se han exportado


correctamente por ejemplo intentando mostrar el valor de $KEY_CITY
por terminal:

# echo $KEY_CITY

Que nos debera devolver el nombre que hayamos introducido, en este


caso Barcelona. Ahora ejecutaremos el script clean-all que se
encargar de eliminar una posible carpeta de claves anteriormente
creada.

# ./clean-all

Hecho esto vamos a crear el par de claves de la propia Autoridad


Certificadora (CA):

# ./build-ca

Que nos preguntar acerca de los datos configurados anteriormente:

Country Name (2 letter code) [ES]:


1
State or Province Name (full name) [BARCELONA]:
2
Locality Name (eg, city) [Barcelona]:
3
Organization Name (eg, company) [SobreBits]:
4
Organizational Unit Name (eg, section) [IT]:
5
Common Name (eg, your name or your server's hostname)
6
[micommonnamel]:
7
Name [minombredeclave]:
8
Email Address [micorreo@micorreo.com]:
Llegados aqu ya somos capaces de generar nuestros propios
certificados firmados. Con ello crearemos nuestro certificado para el
servidor VPN (clave privada) y los parmetros Diffie-
Hellman utilizados para establecer la conexin SSL/TLS. Para el
certificado del servidor:

# ./build-key-server raspberry.home.local
Se nos preguntarn los mismos datos que en el momento de la
generacin de los certificados de la CA, con lo que contestaremos con
los datos deseados y seguiremos las instrucciones. Ahora vamos con
los parmetros Diffie-Hellman:

# ./build-dh

Y por ltimo con la clave para cada uno de los usuarios que se
conecten va VPN:

# ./build-key Nombreusuario

Y seguiremos los pasos rellenando los campos que se nos pregunten.


Si ahora nos vamos a la carpeta ./keys (o la que hayamos asignado en
el archivo vars) encontraremos un buen puado de archivos con
distintos fines. Vamos ver qu nos interesa de aqu para esta parte
del tutorial:
ca.crt: Este es el certificado pblico de la CA, que tendremos que usar
en todos los clientes y en el servidor.
raspberry.home.local.crt y raspberry.home.local.key: Certificado
pblico y privado respectivamente del servidor. Solo los usaremos en
el servidor.
dh1024.pem: Los parmetros Diffie-Hellman que se ubicarn slo en
la carpeta de OpenVPN del servidor.
Nombreusuario.crt y Nombreusuario.key: Certificados pblico y
privado de usuario que utilizaremos en los dispositivos de dicho
usuario.
As que vamos a distribuir los distintos archivos en su sitio dentro del
servidor:

# cp ca.crt /etc/ssl/certs/Sobrebits_CA.crt

# cp raspberry.home.local.crt /etc/ssl/certs/

# cp raspberry.home.local.key /etc/ssl/private/

# cp dh1024.pem /etc/openvpn/

NOTA: La ubicacin de los certificados se puede configurar a mano en


el archivo de configuracin correspondiente de OpenVPN, pero los he
copiado a los directorios donde se almacenan estos archivos en
Raspbian para mantener cierta coherencia en el sistema.
CONFIGURACIN DEL SERVIDOR OPENVPN EN RASPBIAN
Con el tema de los certificados solucionado ahora toca afrontar la
configuracin del servidor OpenVPN en si. OpenVPN al arrancar, por
defecto, intenta iniciar todas las conexiones VPN configuradas en los
archivos *.conf dentro de su directorio /etc/openvpn/. Con su
instalacin, al igual que trae easy-RSA para no complicarnos mucho la
vida con el tema de los certificados, tambin trae una configuracin
por defecto sobre la que podremos trabajar. Lo primero que haremos
ser copiar esta configuracin a nuestro directorio de OpenVPN para
trabajar sobre el:

$ sudo cp /usr/share/doc/openvpn/examples/sample-config-
files/server.conf.gz /etc/openvpn/

Y descomprimimos el contenido del archivo:

$ cd /etc/openvpn

$ gunzip server.conf.gz

Esto nos dejar ya el archivo server.conf editable:

$ sudo nano server.conf

El archivo es bastante extenso pero est muy bien documentado,


adems incorpora una configuracin out of the box funcional, por lo
cual me centrar en las opciones que yo he tocado en un inicio para
que todo funcione. No dudis en indagar un poco ms al respecto, yo
desde luego lo har:

# Los certificados anteriormente creados y ubicados.


1ca /etc/ssl/certs/Sobrebits_CA.crt
2cert /etc/ssl/certs/raspberry.home.local.crt
3key /etc/ssl/private/raspberry.home.local.key # This file should be kept
4secret
5
6# Parmetros Diffie-Hellman
7dh /etc/openvpn/dh1024.pem
8
9# Habilitamos a los clientes conectados para que puedan acceder a la
10subnet
11# interna
push "route 192.168.66.0 255.255.255.0"
La parte de configuracin propiamente dicha del servidor OpenVPN ya
la tenemos completa, ahora solo nos falta reiniciar el servicio
OpenVPN, lo que cargar todos los archivos *.conf de la carpeta
/etc/openvpn, con lo cual quedar creada nuestra interfaz tun0.
$ sudo /etc/init.d/openvpn restart

CONFIGURAR IP FORWARDING EN LA RASPBERRY PI


En este punto del tutorial ya tenemos la configuracin del servidor
OpenVPN de nuestra Raspberry Pi lista. Sin embargo, si nos
conectamos ahora va OpenVPN poco o nada podremos hacer ya que
cuando nuestro ordenador cliente intente alcanzar cualquier red fuera
de la que le hemos configurado (por defecto la 10.8.0.0/24) los
paquetes llegarn a la interfaz virtual tun0 de la Raspberry Pi y no
saltarn a ninguna otra red porque por defecto ese comportamiento
no viene configurado en Raspbian.

Al comportamiento descrito anteriormente se le llama IP forwarding,


que es lo que vamos a configurar ahora. Primero habilitamos el
forwarding de paquetes en el sistema:

$ sudo su

# echo 1 > /proc/sys/net/ipv4/ip_forward

Esta configuracin se perder con el reinicio del sistema. Si queremos


que el cambio sea persistente deberemos editar el
archivo /etc/sysctl.conf y descomentar la siguiente lnea:
1net.ipv4.ip_forward = 1
Lo siguiente que debemos hacer es configurar Iptables con las reglas
necesarias para que el trfico sea enrutado correctamente:

$ sudo iptables -A FORWARD -i eth0 -o tun0 -m state --state


ESTABLISHED,RELATED -j ACCEPT

$ sudo iptables -A FORWARD -s 10.8.0.0/24 -o eth0 -j ACCEPT

$ sudo iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j


MASQUERADE

Al igual que con el IP forwarding estas reglas se perdern en el


reinicio del sistema. Para hacer estas reglas persistentes de una
forma fcil podemos valernos del paquete iptables-persistent que
guardar la configuracin actual de Iptables y la volver a cargar
despus de cada reinicio. (para desbloquear esta parte os pido que
realicis una accin social con la que ayudar al blog)
Montar un servidor casero con Raspberry Pi
(Parte 8): NAS con Raspberry Pi y Samba
En este nuevo tutorial del servidor casero con Raspberry Pi veremos
como montar un NAS casero con la Raspberry Pi, Samba y un disco
duro externo.

Hace 4 meses desde la ltima parte publicada de esta serie de


tutoriales que hoy retomo con la intencin de aadir un nuevo servicio
a mi Raspberry Pi, la comparticin de archivos con Samba.
El bajo consumo y precio de la Raspberry Pi convierten al dispositivo
en una forma ideal de montar un NAS casero, que si bien no tendr el
rendimiento de productos creados especficamente para realizar dicha
funcin, s que nos ofrecer una solucin totalmente funcional para
centralizar archivos dentro de nuestra red local.

ESQUEMA DE COMPARTICIN EN LA RED


Este tutorial est enfocado a una pequea red domstica, por lo que
no tiene mucho sentido crear complejos sistemas de comparticin, no
obstante, como ha venido siendo costumbre en estos tutoriales, s que
intentaremos crear un sistema que nos permita ver algunas de las
funcionalidades que nos ofrece el servicio Samba y que adems
aporten algo de valor aadido.

El esquema que propongo y que emplear para el tutorial (el mismo


que tengo actualmente funcionando en mi casa) ser el siguiente: Se
crearn 3 carpetas que compartiremos con Samba, 2 de ellas sern
carpetas personales para los dos usuarios que existen en la red donde
slo ellos podrn leer y escribir, la tercera carpeta ser compartida
para ambos, donde podrn leer y escribir a placer.

Vamos a poner los datos concretos con los que ejemplificar todo el
tutorial:

Usuarios: usuario1 y usuario2.


Grupos: home.
Carpetas: carpus1, carpus2 y compartida.

MONTAR EL DISCO DURO EXTERNO EN LA RASPBERRY PI


Esta parte evidentemente es opcional. Si lo que quieres es compartir
una carpeta dentro de tu sistema de ficheros de la Raspberry Pi
puedes saltarte este paso. En mi caso como no podra compartir una
gran cantidad de espacio debido a las limitaciones de la tarjeta SD me
he decantado por compartir un disco duro externo de 1,5TB.

Para hacer esta parte ms fcil y no extender mucho ms el post de lo


que ya se va a extender he formateado el disco duro desde mi
ordenador de escritorio en formato ext4 antes de conectarlo a la
Raspberry.

Antes que nada deberemos crear en nuestro sistema de archivos la


carpeta donde montaremos el disco duro, en este tutorial se
utilizar /mnt/NAS:

$ sudo mkdir /mnt/NAS

Posteriormente debemos identificar el disco duro en nuestro sistema.


Para ello nos valdremos de:

$ blkid

Que nos debera mostrar una lnea parecida a la siguiente:

/dev/sda1: LABEL="NAS" UUID="37cdcd88-696a-4c63-9c1b-66cdcbb89b3f"


1
TYPE="ext4"
Copiaremos el UUID, que ser lo que utilizaremos para identificar el
dispositivo dentro del fichero fstab que pasaremos a editar ahora:

$ sudo nano /etc/fstab

Al final de este archivo debemos crear una lnea similar a la siguiente:

UUID=37cdcd88-696a-4c63-9c1b-66cdcbb89b3f /mnt/NAS ext4


1
defaults,noatime 0 0
Lo que estamos haciendo en esta lnea es indicar dnde y como
queremos montar nuestro disco duro en el sistema de archivos. En
este caso lo estamos montando en /mnt/NAS y con los parmetros por
defecto. Recomiendo que si no conocis el funcionamiento de este
archivo antes de hacer nada y copiar y pegar a lo bruto la revisis
para entender exactamente qu implica cada parmetro.

Editado el archivo lo guardamos, cerramos y montamos el disco en


nuestro sistema de ficheros:

$ sudo mount -a
Si la sintaxis era correcta y no aparece error alguno al ejecutar mount
ya tendremos nuestra unidad montada en /mnt/NAS.

INSTALAR SAMBA EN RASPBIAN


No estoy seguro de si esto es necesario en una instalacin limpia de
Raspbian, puesto que yo borr una cantidad enorme de paquetes de
Raspbian tal y como indiqu en el tutorial correspondiente, de todos
modos no tiene mucho misterio utilizando apt:

$ sudo apt-get install samba samba-common-bin

Esto ser todo lo que necesitaremos instalado para continuar con el


tutorial.

CREACIN DE USUARIOS Y GRUPO


Toca crear los usuarios y el grupo que interactan con las carpetas
compartidas. Si habis trabajado con comparticiones en Windows la
mecnica de permisos es parecida en el sentido de que existen dos
permisos con los que tendremos que tratar, con los permisos del
sistema de archivos y con los permisos de Samba.

Como nuestro servidor Samba se encuentra en un ambiente donde no


existe un Active Directory ni un LDAP contra el que autenticar
usuarios deberemos crear los usuarios en el propio servidor y en
Samba.

Para crear los usuarios en nuestra Raspbian usaremos:

$ sudo adduser -shell /bin/false --no-create-home usuario1

$ sudo adduser -shell /bin/false --no-create-home usuario2

Como podis observar le he pasado un par de parmetros al comando


adduser, totalmente opcionales pero que personalmente recomiendo:

-shell /bin/false: El parmetro -shell sirve para asignar un intrprete


de rdenes (shell) distinto al que viene asignado por defecto en
nuestro sistema. Asignarle una shell falsa har que el usuario no
pueda logearse en el sistema ni acceder va ssh, siendo ambas cosas
innecesarias adems de un potencial riesgo en este entorno.
no-create-home: Esta otra opcin es autoexplicativa. Forzamos a
adduser a no crear un directorio home en el sistema, interesante para
no llenar el directorio de carpetas innecesarias.
Posteriormente los aadimos a la lista de usuarios de Samba:

$ sudo smbpasswd -a usuario1

$ sudo smbpasswd -a usuario2

Ahora toca crear el grupo y unir a nuestros dos usuarios a dicho


grupo:

$ sudo addgroup home

$ sudo adduser usuario1 home

$ sudo adduser usuario2 home

Llegados aqu ya tendremos lo necesario para implementar la


seguridad pertinente en las carpetas compartidas que vamos a crear a
continuacin.

CREACIN DE CARPETAS COMPARTIDAS Y ASIGNACIN DE PERMISOS


Vamos a crear las carpetas que vamos a compartir dentro de nuestro
disco duro externo siguiendo el esquema anteriormente descrito:

$ cd /mnt/NAS

$ sudo mkdir carpus1 carpus2 compartida

Con las carpetas creadas es hora de poner un orden a los permisos de


las carpetas. Tal y como hemos visto en el esquema necesitamos que
los usuarios puedan leer y escribir en su carpeta personal y en la
compartida, pero no en la carpeta personal de los dems. Para ello
primero vamos a cambiar la propiedad de las carpetas a los usuarios y
grupos correspondientes:

$ sudo chown -R usuario1:usuario1 carpus1

$ sudo chown -R usuario2:usuario2 carpus2

$ sudo chgrp -R home compartida

Y asignamos los permisos correspondientes a todas las carpetas:


$ sudo chmod -R 770 *

Estos permisos evidentemente no son al azar. Lo que pretendemos es


que solo el usuario y grupo propietarios puedan leer y escribir en la
carpeta y que el resto de usuarios no pueda acceder. Puesto que el
grupo usuario1 y usuario2 estn compuestos nicamente por los
usuarios con el mismo nombre nos aseguramos que nadie ms puede
acceder. Si no tenemos muy fresco el tema de los permisos es mejor
que lo repasemos para saber exactamente qu estamos haciendo.
Hay una ltima cosa tenemos que tener en consideracin con el tema
de los permisos. En la carpeta compartida escribirn usuario1 y
usuario2, por lo que cuando creemos un archivo ah dentro, como su
grupo principal es usuario1 y usuario2 respectivamente nos
encontraremos con que un usuario no podr modificar lo creado por el
otro. La solucin a esto se encuentra en el bit setgid. Asignar este bit
a la carpeta compartida har que todo lo que creemos bajo este
directorio sea asignado al grupo de la carpeta principal, por lo tanto,
lo que cree usuario1 ser asignado al grupo home, lo que permitir
que ambos puedan modificarlo.
Asignar el bit es muy sencillo, simplemente ejecutaremos:

$ sudo chmod g+s compartida

Ejecutar un ls -l nos mostrar el resultado de todo lo hecho en este


apartado:

$ ls -l
1drwxrws--- 2 root home 4096 Oct 10 21:13 compartida
2drwxrwx--- 2 usuario1 usuario1 4096 Oct 10 22:41
3carpus1
4drwxrwx--- 2 usuario2 usuario2 4096 Oct 10 21:12
carpus2
Como vemos, todas las carpetas tienen permiso 770, y en la carpeta
compartida podemos ver una s en la casilla de ejecucin de grupo,
lo que muestra que est habilitado el bit setgid.

CONFIGURACIN DE SAMBA EN LA RASPBERRY PI


Hecha toda la preparacin falta precisamente de lo que trata este
post: configurar Samba en la Raspberry Pi. En este tutorial no voy a
tocar nada que no sea necesario para la configuracin propuesta en el
esquema del principio de la entrada, esto se debe a que las opciones
de Samba son muy extensas y difcilmente podra cubrirlas en una
entrada de este estilo. As que vamos al lo:
Como siempre lo primero que haremos ser crear un backup del
archivo de configuracin que vamos a editar, para as poder volver
atrs en caso de que toquemos algo que no debemos.

$ sudo su

# cd /etc/samba

# mv smb.conf smb.conf.orig

Despus de esto crearemos una copia limpia de comentarios del


archivo original. Esto lo haremos mediante la herramienta de
verificacin de la configuracin de smb.conf:

# testparm -s smb.conf.orig > smb.conf

El archivo original est muy bien documentado, as que siempre es til


dirigirse a l en busca de informacin sobre los parmetros as como
podemos hacerlo en la pgina man de smb.conf.

Vamos a editar nuestro archivo de configuracin generado:

# nano smb.conf

Observaremos que hay distintas secciones separadas en el archivo de


configuracin. De las ya existentes solo tocaremos la seccin [global]
en la que aadiremos lo siguiente:

1security=user
Si bien este es el comportamiento por defecto siempre es interesante
tenerlo puesto.
Ahora generaremos nuestras propias secciones, que correspondern a
las distintas carpetas que compartamos. Puesto que en esencia las
tres secciones son iguales pondr los comentarios solo en la primera:
[carpus1] # Nombre del recurso compartido
1 comment = Carpeta personal de usuario1 # Descripcin.
2 path = /mnt/NAS/carpus1 # Ruta de la carpeta.
3 read only = No # Indicamos que no es de solo lectura.
4 valid users = usuario1 # Usuarios que pueden acceder al recurso.
5 write list = usuario1 # Usuarios que pueden escribir en el
6recurso.
7 create mask = 0660 # Mscara de creacin de archivos.
8 directory mask = 0770 # Mscara de creacin de directorios.
9
10[carpus2]
11 comment = Carpeta personal de usuario2
12 path = /mnt/NAS/carpus2
13 read only = No
14
valid users = usuario2
15
write list = usuario2
16
17 create mask = 0660
18 directory mask = 0770
19
20[compartida]
21 comment = Carpeta compartida
22 path = /mnt/NAS/compartida
23 read only = No
24 valid users = @ home
25 write list = @ home
26 create mask = 0660
directory mask = 0770
NOTA: En valid users y write list de la seccin compartida es @home
sin espacio.
Quiero pararme un momento a hablar de los parmetros create
mask y directory mask. Estos dos parmetros determinarn los
permisos que se aplicarn a los archivos y directorios creados
respectivamente. Es importante especificar esto, sobretodo en la
carpeta compartida, puesto que necesitamos que los archivos se
generen con permiso de escritura para el grupo, de no ser as el otro
usuario que accede a la carpeta no podra modificar los permisos. Por
otro lado, tanto en la compartida como en las personales queremos
evitar que se de ningn tipo de permiso a otros usuarios, por lo cual
es importante que se apliquen estos permisos. De nuevo recomiendo
echar un ojo a los permisos en GNU/Linux ante cualquier duda al
respecto.
Hecho esto guardamos el archivo y ejecutamos la herramienta de
comprobacin del archivo smb.conf:

# testparm
Que no debera mostrarnos errores. Posteriormente reiniciamos el
servicio Samba:

# service samba restart

COMPROBACIN DEL FUNCIONAMIENTO


Con todo esto hecho ya tendramos que tener nuestro servidor Samba
funcionando en la Raspberry Pi. Como ltima parte del tutorial os dejo
de forma genrica como acceder a los recursos compartidos con
Samba desde GNU/Linux y Microsoft Windows para que podis
comprobar que todo funciona bien. (para desbloquear esta parte os
pido que realicis una accin social con la que ayudar al blog)

Como ltimo consejo recomiendo que entris va ssh y vayis mirando


como se generan los permisos y las propiedades de los nuevos
archivos de cada una de las carpetas creadas para as ver si se estn
aplicando las configuraciones de seguridad correctamente.

Bonus link: Con nuestro NAS casero montado y funcionando puede


interesarnos controlar el uso del espacio de nuestras unidades con
este script.

Script bash para monitorizar el espacio en GNU/Linux


Un buen uso para el envo de correos desde la lnea de comandos que
vimos en la anterior entrada es usarlo junto a herramientas de
monitorizacin del sistema. Juntar la utilizacin de una de estas
herramientas con el envo de correo va a permitirnos estar todo lo
informados que deseemos (y seamos capaces de estar) acerca del
estado de nuestros sistemas.

SCRIPT PARA LA SUPERVISIN DEL ESPACIO EN DISCO DE LOS


SISTEMAS DE FICHEROS LOCALES
La naturaleza abierta de GNU/Linux hace que existan cientos de
aplicaciones, todas ellas muy vlidas, encargadas de tareas
relacionadas con la supervisin del sistema. No obstante, no hay nada
como escribir un poco de cdigo, aunque sea tan sencillo como este, y
que funcione.
Aqu os dejo un pequeo script con el que monitorizar el espacio de
los sistemas de ficheros locales que deseemos.
#!/bin/bash
1
2####### Configuracin del script #######
3
4# Sistemas de ficheros a chequear
5devices[0]=/dev/sda1
6devices[1]=/dev/sdb1
7devices[2]=/dev/sdd1
8#devices[3]=
9#devices[4]=
10#....
11
12# Destinatario del correo
13destinatario="micorreo@dominio.com"
14
15####### Cuerpo del script ########
16
17# Recorremos el array de dispositivos a monitorizar
18for device in ${devices[@]};
19do
20 # Consultamos la ocupacin del dispositivo
21 ocupacion=$(df -H | grep $device | expand | tr -s " " | cut -d " " -f5 | cut
22-d "%" -f1)
23 # Si la ocupacin es igual o mayor al 85%...
24 if [ $ocupacion -ge 85 ];
25 then
26 # Preparacin y envo del correo
27 correo=$(echo "WARNING, " $device en `hostname` al $ocupacion"%
28de ocupacin!!")
29 asunto=$(echo "Alerta de espacio en " `hostname` " - " $device)
30 echo $correo | mail -s "$asunto" $destinatario
31 fi
done
Al principio del script hay una pequea rea de configuracin donde
asignar las particiones a monitorizar, as como configurar el email al
que enviaremos las alertas. Por supuesto, sois totalmente libres de
modificar y adaptar este pequeo script a vuestro gusto.
Yo lo tengo planificado en el cron de mi servidor domstico para que
se ejecute cada noche a diario, y as evitar que mi servidor de
ficheros se quede sin espacio.