Archivo de la categoría: GNU/Linux

Restaurar la programación de artículos en WordPress

Hace poco me fui de viaje y vi que todas las entradas programadas para mi blog fallaron. El motivo por el cual la programación de los artículos en WordPress falla normalmente es por el uso de plugins. En especifico por el uso de plugins que cachean las páginas. Al cachear las páginas no se ejecuta el cron de WordPress y si no se ejecuta el cron entonces WordPress no publica los artículos programados.

Como no quiero perder toda la velocidad de carga que obtengo cacheando las páginas de mi blog he encontrado un método para arreglar el problema sin tener que desinstalar ningún plugin. Puedes instalar OTRO plugin para solucionar el problema o añadir un cronjob. En este artículo voy a explicar como arreglar la programación perdida de los artículos añadiendo un cronjob.

Hay hostings que puedes añadir el cronjob usando el panel de control (lo vas a tener que buscar tu en la pagina de ayuda de tu hosting) o si tienes control entero sobre tu servidor vas a poder añadir el conjob tu mismo. Básicamente se trata de ejecutar periódicamente el siguiente link

http://tudominio.com/wp-cron.php?doing_wp_cron

En condiciones normales este link se carga cada vez que un usuario entra en el blog pero si usamos cache la página no se carga y perdemos las publicaciones. Para poder publicar las entradas programadas y mantener nuestra cache tendremos que ejecutar este link de modo automático gracias al cronjob.

Un cronjob requiere de un comando (no de un link). Así que lo que he escrito un comando para que el link sea cargado sin guardar el HTML en ningún sitio:

wget -O /dev/null http://tudominio.com/wp-cron.php?doing_wp_cron

Personalmente lo he puesto cada hora, pero lo puedes poner cada 5minutos. No usa casi recursos así que difícilmente vas a sobrecargar el blog.

Recuerda que la primera vez que accedas al link después de los errores de programación, todas las entradas falladas se van a publicar a la vez. Consecuentemente es interesante que revises la programación de los posts antes de acceder al link.

Como hacer una copia de seguridad completa de nuestro servidor, base de datos y WordPress

Los backups son necesarios para cualquier sistema para prevenir la pérdida de datos. Siguiendo un poquito con la tónica de los últimos posts, instalar wordpress en un servidor propio y usar certificados SSL para nuestro WordPress, esta vez lo que haremos será un backup completo de nuestro WordPress. En este post lo que hago es crear un cronjob, osease un script que se ejecute a diario y haga una copia completa de nuestra base de datos juntamente con distintas carpetas que queramos conservar de nuestro blog.

Generamos un dump de todas las bases de datos

La base de datos es uno de los componentes más importantes de cualquier sistema. Es donde históricamente se ha guardado la información. Para hacer una copia de la base de datos necesitaremos mysqldump. Esto nos permitirá sacar una copia consistente de la base de datos.  Para obtener la copia de todas las bases de datos ejecutaremos el comando

mysqldump -u[usuario] -p[contraseña] --single-transaction --quick --all-databases > output.sql

El fichero output.sql contendrá toda la información en la base de datos.

Agruparemos todos los directorios y documentos en un solo archivo

Una vez ya tengamos generado el dump de nuestra base de datos lo que tendremos que hacer es crear un archivo único para mejorar la transportabilidad del backup. En mi caso también lo comprimo usando gzip para ahorrar espacio, ya que raramente se consultan/usan los backups y así ahorro espacio. En mi caso he usado tar (para una introducción podéis leer mi anterior post a tar) para mantener los permisos de cada archivo.

tar cfz /home/donde/quieras/archivo.tar.gz /var/www/ /directorio/hacia/backup/output.sql

En el comando anterior vemos que hemos creado un archivo comprimido que contiene el directorio var/www, y el dump que hemos hecho de la base de datos /directorio/hacia/backup/output.sql

Subiremos el archivo comprimido a un servidor externo

Para asegurarnos que cualquier problema que pueda tener nuestra máquina no afecte a nuestros backups subiremos el archivo comprimido a un servidor externo. Imagínate que haces sólo los backups pero los dejas en tu ordenador y el disco duro se estropea. Si pasa eso no podrías recuperar la información. Por esto es importante guardar copias de seguridad en distintos sitios.

Para este apartado he creado como un mini-script con las instrucciones para que el cliente FTP lo ejecute y haga la copia. En mi caso lo voy a guardar con el nombre ftp.txt

open [url o IP]
user usuario contraseña
passive #algunas veces requerido
put /home/donde/tenías_el/archivo.tar.gz nombre_del_archvo_en_el_ftp.tar.gz
bye

Finalmente ejecutaremos este trozo de código con

 ftp -n < ftp.txt

Asignaremos un cronjob que haga backups y los salvaguarde

A partir de la segunda vez que tienes que realizar una tarea uno tiene que empezar a pensar de que modo puede optimizar el proceso. Lo que he decidido hacer es crear un cronjob para que haga una copia de seguridad a diario y la suba al servidor externo mediante FTP.

echo "Starting script: $(date)"
day=$(date +"%d")

echo "Doing the mysql dump of all tables"
mysqldump -u[usuario] -p[contraseña] --single-transaction --quick --all-databases > output.sql

echo "Compressing the websites and the mysql dump into one file"
tar cfz /home/donde/quieras/archivo.tar.gz /var/www/ /directorio/hacia/backup/output.sql

echo "open url o IP 
user usuario contraseña 
passive #algunas veces requerido 
put /home/donde/tenías_el/archivo.tar.gz nombre_del_archvo_en_el_ftp.tar.gz 
bye" > ftp.txt

echo "Executing FTP and uploading the file"
ftp -n < ftp.txt

rm ftp.txt

Este vendría a ser el script que va a ejecutar el cronjob. Pero para ejecutar el script de forma automática tendremos que guardarlo propiamente como cronjob. Para esto usaremos el siguiente comando para editar los cronjobs de nuestro sistema.

crontab -e

y dentro del fichero, al final, escribiremos el siguiente comando

00 4 * * * sh /camino/hacia/cronjobs/cron_backup.txt > /dev/null 2>&1

Este comando ejecuta el script en /camino/hacia/cronjobs/cron_backup.txt cada día (los asteriscos) a las 4:00 (am) sin guardar el output (> /dev/null 2>&1). Ahora guardaremos el fichero y ya lo tendremos inicializado.

Para aprender un poquito más sobre los cronjobs podéis leer mi entrada anterior dónde lo explico más detalladamente.

Finalmente para recuperar los archivos

Cuando lo más temido pasa, cuando se nos estropea el ordenador y tenemos que ir a buscar los backups, lo tendremos todo preparado.

Primero nos logearemos con el cliente FTP y nos descargaremos el archivo con los backups.

ftp [url o IP]

pondremos el nombre de usuario y contraseña cuando nos lo pida. Una vez logueados descargaremos el fichero con el backup en nuestro ordenador local

get Nombre_del_backup.tar.gz

Saldremos de la sesión para descomprimir y extraer los archivos

tar xf Nombre_del_backup.tar.gz

Todo lo que sea blogs WordPress tendremos que copiar los ficheros en /var/ww/ otra vez y volver a configurar el apache. En cuanto la base de datos tendremos que importar el dump

mysql -u[usuario] -p output.sql

Y de este modo ya habremos recuperado todo lo que temíamos haber perdido.

Como ejecutar DALI para el alineamiento de proteínas con las librerías de Fortran originales

DALI es un programa de comparación de estructuras de proteínas de finales del siglo pasado. A pesar de ser un programa ampliamente usado, el código hace décadas que no ha sido tocado por lo que sigue usando librerías de unos 20 años de antigüedad. Librerías Fortran que ya no están en la versión actual del gcc.

El problema que me daba es:

error while loading shared libraries: libg2c.so.0: cannot open shared object file: No such file or directory

Como quería usar este programa tuve que encontrar una solución. Al final lo que conseguí es instalar una versión antigua de gcc para poder usar las librerías usando el compilador antiguo de Fortran (gfortran).

Al final encontré la única solución. Consiste en instalar el compilador de GNU y después compilar y ejecutar dalilite usando la versión antigua.

Para empezar nos bajaremos la versión antigua del compilador de GNU, la versión gcc-3.4.6

wget https://ftp.gnu.org/gnu/gcc/

descomprimiremos el archivo comprimido, y crearemos el directorio dónde pondremos las librerías

tar -zxvf gcc-3.4.6.tar.gz
cd gcc-3.4.6
mkdir build
cd build

Configuraremos gcc-3.4.6

../configure --enable-shared –prefix=/cualquier/directorio --disable-multilib --disable-bootstrap # /cualquier/directorio puede ser por ejemplo /home/roc/herramientas/gcc-3.4.6

Ahora hacemos un build y lo instalamos. Esto va a tardar un rato y se instará en el directorio previamente seleccionado

make -j 4
make install

Ahora que ya tenemos nuestra copia de gcc-3.4.6 instalada en /cualquier/directorio necesitamos hacer las librerías visibles.

export PATH=/cualquier/directorio/bin:$
export LD_LIBRARY_PATH=/cualquier/directorio/

Ahora dalilite debería funcionar. Recuerda en recompilarlo con el Makefile. Además cada vez que quieras ejecutarlo deberías usar las dos lineas anteriores

Espero que os haya servido!

Texmaker al estilo de Sublime text (monokai)

Sublime text, aunque es un editor de texto que me gusta mucho, he estado buscando alternativas. He encontrado textmaker. Texmaker es  un editor de latex que nos permite compilar el documento pdf además de añadir otras interesantes features. Lo que no me gustaba era el tema (theme) que tenía por defecto. Así que buscando di con la solución. Usar el theme de Sublime text, llamado monokai.

Para cambiarlo simplemente tenemos que ir a $HOME/.config/xm1 (tanto en linux, como en MacOS y editar el fichero texmaker.ini y reemplazar las siguientes lineas de la principio del fichero:

Color\Background=@Variant(\0\0\0\x43\x1\xff\xff\0\0++66\0\0)
Color\Command=@Variant(\0\0\0\x43\x1\xff\xff&&\x8b\x8b\xd2\xd2\0\0)
Color\Comment=@Variant(\0\0\0\x43\x1\xff\xffllqq\xc4\xc4\0\0)
Color\Highlight=@Variant(\0\0\0\x43\x1\xff\xff\a\a66BB\0\0)
Color\Keyword=@Variant(\0\0\0\x43\x1\xff\xff\xdc\xdc\x32\x32//\0\0)
Color\KeywordGraphic=@Variant(\0\0\0\x43\x1\xff\xff\x85\x85\x99\x99\0\0\0\0)
Color\Line=@Variant(\0\0\0\x43\x1\xff\xff\a\a66BB\0\0)
Color\Math=@Variant(\0\0\0\x43\x1\xff\xff**\xa1\xa1\x98\x98\0\0)
Color\NumberGraphic=@Variant(\0\0\0\x43\x1\xff\xff\xcb\xcbKK\x16\x16\0\0)
Color\Standard=@Variant(\0\0\0\x43\x1\xff\xff\x83\x83\x94\x94\x96\x96\0\0)
Color\Todo=@Variant(\0\0\0\x43\x1\xff\xff\xd3\xd3\x36\x36\x82\x82\0\0)
Color\Verbatim=@Variant(\0\0\0\x43\x1\xff\xff\xb5\xb5\x89\x89\0\0\0\0)

Instalar ubuntu desde un USB

Instalar Ubuntu (o la mayoría de distribuciones más o menos conocidas) puede hacerse utilizando un USB sin necesidad de quemar (burn) un CD. Es mucho más simple de lo que parece si se siguen los puntos de la lista:

  1. El primer paso es descargar Ubuntu.
  2. Comprobar el md5um
    • Usar el siguiente el comando en la terminal: md5sum ubuntu-11.10-dvd-i386.iso
    • Comprobar el hash que te da como resultado con los hashes oficiales de canonical.
  3. Para finalizar preparar Ubuntu en un USB vacío. Para esto usaremos UNetbootin y seguiremos las “instrucciones”.

Más fácil imposible. Para más info la página oficial.

 

Me cansé de editar documentos Latex a mano

Hace ya un tiempo escribía mis ficheros Latex a mano. Para los que no lo sepan, es un tipo de documento dónde escribes lo que quieres ver. A diferencia de Word no lo puedes hacer de forma visual sino que para que nos entendamos lo “programas”. Una vez terminado el documento lo compilas (como los programas) y tienes un pdf muy bonito. Latex lo hace bastante fácil para los dominios técnicos con las fórmulas y todo eso.

Escribirlos a mano queda de hacker badass, pero es algo duro. Para esto busqué una solución sencilla. Y esta solución la voy a compartir con vosotros (que majo que soy :D)
Lo mejor que he encontrado ha sido Kile. Lo mejor de todo es que funciona en Linux (party!!!). Lo recomiendo porqué:

  • Tiene interfaz gráfica
  • Completa los comandos
  • Tiene corrector ortográfico
  • Compila y muestra el documento con un click
  • Te señala los errores
  • Puedes tener la lista de tus ficheros latex

Nada más que añadir!

Arreglar las teclas de funciones para cambiar el brillo del portátil con Lubuntu

Como ya habrás notado en los últmos posts, tras la reinstalación de Lubuntu algunas he reconfigurado algunas cosas de mi ordenador. Una de estas ha sido arreglar las teclas de funciones para cambiar el brillo de la pantalla del portátil des del teclado.

La primera solución que encontré y que no funciona des del teclado es creando un bash script con la siguiente linea:

echo X > /sys/class/backlight/intel_backlight/brightness

Dónde X es el valor del brillo. Cada vez que quería cambiar el brillo tenia que ejecutar el fichero desde la consola cambiando la X por un numero del 1 al 4000.

La solución que me ha arreglado las teclas de funciones de forma permanente permitiéndome modificar la intensidad de brillo de la pantalla ha sido la siguiente. Primero de todo ejecutamos el siguiente comando en la terminal:

sudo gedit /etc/default/grub

Luego cambiamos

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

por

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash acpi_osi="

guardamos los cambios y ejecutamos la siguiente linea en la terminal

sudo update-grub

Sinceramente no entiendo muy bien el porqué de las lineas anteriores, pero la conclusión es que funciona 😀

Crear atajos de teclado en Lubuntu

Como ya sabréis he reinstalado Lubuntu (es como Ubuntu pero usando la interfaz gráfica LXDE). Lo primero que hago es crear un atajo en el teclado para abrir la consola pulsando la tecla Windows + T.

Primero tendremos que encontrar el fichero, que en mi caso está en:

/home/<Nombre_de_usuario>/.config/openbox/lubuntu-rc.xml

Luego en la sección de <keyboard> tenemos que añadir el comando que queramos tener. En mi caso para conseguir abrir la consola con la tecla windows + T he añadido las siguientes lineas:

<keybind key="W-T">
      <action name="Execute">
        <command>lxterminal</command>
      </action>
    </keybind>

Notese que en mi caso es la letra W para indicar tecla  Windows. Otros comandos:

A- significa “Alt+”
C- significa “Ctrl+”
S- significa “Shift+”
W- significa la tecla “Windows”

Para coger ideas de como se hacen las cosas lo que puedes hacer es mirar otros ejemplos dentro el fichero.

Cambiar el layout del teclado al español con Lubuntu

Después de una nueva instalación el teclado no me correspondía con la configuración del sistema. La primera solución que encontré para cambiar fue la siguiente aunque no nos cambia el layout de forma permanente. Simplemente se tiene que ejecutar el comando en la consola.

setxkbmap -layout "es"

Para conseguirlo de forma “permanente” he usado el Autostat que ofrece LXDE. Lo encontramos en:

Menu inicio > Preferences > Default applications for LXSession

En la nueva ventana vamos a la pestaña de Autostart y en “manual autostarted applications” añadimos el comando anterior. De esta forma cada vez que Lubuntu arranque se ejecutará el comando fijando el teclado al layout español.

Manual para instalar OpenVPN en Ubuntu con script

Hace ya algun tiempo me hice con un servidor y lo voy usando para hacer mis cosicas. Como por ejemplo instalar rTorrent para poder bajarme ficheros el cual estuvo acompañado de otro post para mover ficheros entre el servidor y mi ordenador. Esta vez lo que quiero hacer es usar el server como túnel para evitar contenidos restringidos en el país dónde estoy y mejorar la seguridad en redes abiertas.
Primero de todo tendremos que instalar el software necesario. Para ello ejecutando la siguiente linea en la consola bastará:

wget http://git.io/vpn --no-check-certificate -O openvpn-install.sh; chmod +x openvpn-install.sh; ./openvpn-install.sh

Para los que os gusta hacerlo paso a pasa y configurarlo todo al milímetro al final del post hay un link (en inglés) que os ayudará. Para el resto de mortales el siguiente script lo hace todo, es simplemente un autoinstaller que puede generar claves, revocar certificados y desinstalar OpenVPN.

#!/bin/bash
# OpenVPN road warrior installer for Debian-based distros

# This script will only work on Debian-based systems. It isn't bulletproof but
# it will probably work if you simply want to setup a VPN on your Debian/Ubuntu
# VPS. It has been designed to be as unobtrusive and universal as possible.

if [ $USER != 'root' ]; then
echo "Sorry, you need to run this as root"
exit
fi

if [ ! -e /dev/net/tun ]; then
echo "TUN/TAP is not available"
exit
fi

if [ ! -e /etc/debian_version ]; then
echo "Looks like you aren't running this installer on a Debian-based system"
exit
fi

# Try to get our IP from the system and fallback to the Internet.
# I do this to make the script compatible with NATed servers (lowendspirit.com)
# and to avoid getting an IPv6.
IP=$(ifconfig | grep 'inet addr:' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | cut -d: -f2 | awk '{ print $1}' | head -1)
if [ "$IP" = "" ]; then
IP=$(wget -qO- ipv4.icanhazip.com)
fi

if [ -e /etc/openvpn/server.conf ]; then
while :
do
clear
echo "Looks like OpenVPN is already installed"
echo "What do you want to do?"
echo ""
echo "1) Add a cert for a new user"
echo "2) Revoke existing user cert"
echo "3) Remove OpenVPN"
echo "4) Exit"
echo ""
read -p "Select an option [1-4]: " option
case $option in
1)
echo ""
echo "Tell me a name for the client cert"
echo "Please, use one word only, no special characters"
read -p "Client name: " -e -i client CLIENT
cd /etc/openvpn/easy-rsa/2.0/
source ./vars
# build-key for the client
export KEY_CN="$CLIENT"
export EASY_RSA="${EASY_RSA:-.}"
"$EASY_RSA/pkitool" $CLIENT
# Let's generate the client config
mkdir ~/ovpn-$CLIENT
cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf ~/ovpn-$CLIENT/$CLIENT.conf
cp /etc/openvpn/easy-rsa/2.0/keys/ca.crt ~/ovpn-$CLIENT
cp /etc/openvpn/easy-rsa/2.0/keys/$CLIENT.crt ~/ovpn-$CLIENT
cp /etc/openvpn/easy-rsa/2.0/keys/$CLIENT.key ~/ovpn-$CLIENT
cd ~/ovpn-$CLIENT
sed -i "s|cert client.crt|cert $CLIENT.crt|" $CLIENT.conf
sed -i "s|key client.key|key $CLIENT.key|" $CLIENT.conf
tar -czf ../ovpn-$CLIENT.tar.gz $CLIENT.conf ca.crt $CLIENT.crt $CLIENT.key
cd ~/
rm -rf ovpn-$CLIENT
echo ""
echo "Client $CLIENT added, certs available at ~/ovpn-$CLIENT.tar.gz"
exit
;;
2)
echo ""
echo "Tell me the existing client name"
read -p "Client name: " -e -i client CLIENT
cd /etc/openvpn/easy-rsa/2.0/
. /etc/openvpn/easy-rsa/2.0/vars
. /etc/openvpn/easy-rsa/2.0/revoke-full $CLIENT
# If it's the first time revoking a cert, we need to add the crl-verify line
if grep -q "crl-verify" "/etc/openvpn/server.conf"; then
echo ""
echo "Certificate for client $CLIENT revoked"
else
echo "crl-verify /etc/openvpn/easy-rsa/2.0/keys/crl.pem" >> "/etc/openvpn/server.conf"
/etc/init.d/openvpn restart
echo ""
echo "Certificate for client $CLIENT revoked"
fi
exit
;;
3)
apt-get remove --purge -y openvpn openvpn-blacklist
rm -rf /etc/openvpn
rm -rf /usr/share/doc/openvpn
sed -i '/--dport 53 -j REDIRECT --to-port/d' /etc/rc.local
sed -i '/iptables -t nat -A POSTROUTING -s 10.8.0.0/d' /etc/rc.local
echo ""
echo "OpenVPN removed!"
exit
;;
4) exit;;
esac
done
else
echo 'Welcome to this quick OpenVPN "road warrior" installer'
echo ""
# OpenVPN setup and first user creation
echo "I need to ask you a few questions before starting the setup"
echo "You can leave the default options and just press enter if you are ok with them"
echo ""
echo "First I need to know the IPv4 address of the network interface you want OpenVPN"
echo "listening to."
read -p "IP address: " -e -i $IP IP
echo ""
echo "What port do you want for OpenVPN?"
read -p "Port: " -e -i 1194 PORT
echo ""
echo "Do you want OpenVPN to be available at port 53 too?"
echo "This can be useful to connect under restrictive networks"
read -p "Listen at port 53 [y/n]: " -e -i n ALTPORT
echo ""
echo "Finally, tell me your name for the client cert"
echo "Please, use one word only, no special characters"
read -p "Client name: " -e -i client CLIENT
echo ""
echo "Okay, that was all I needed. We are ready to setup your OpenVPN server now"
read -n1 -r -p "Press any key to continue..."
apt-get update
apt-get install openvpn iptables openssl -y
cp -R /usr/share/doc/openvpn/examples/easy-rsa/ /etc/openvpn
# easy-rsa isn't available by default for Debian Jessie and newer
if [ ! -d /etc/openvpn/easy-rsa/2.0/ ]; then
wget --no-check-certificate -O ~/easy-rsa.tar.gz https://github.com/OpenVPN/easy-rsa/archive/2.2.2.tar.gz
tar xzf ~/easy-rsa.tar.gz -C ~/
mkdir -p /etc/openvpn/easy-rsa/2.0/
cp ~/easy-rsa-2.2.2/easy-rsa/2.0/* /etc/openvpn/easy-rsa/2.0/
rm -rf ~/easy-rsa-2.2.2
rm -rf ~/easy-rsa.tar.gz
fi
cd /etc/openvpn/easy-rsa/2.0/
# Let's fix one thing first...
cp -u -p openssl-1.0.0.cnf openssl.cnf
# Fuck you NSA - 1024 bits was the default for Debian Wheezy and older
sed -i 's|export KEY_SIZE=1024|export KEY_SIZE=2048|' /etc/openvpn/easy-rsa/2.0/vars
# Create the PKI
. /etc/openvpn/easy-rsa/2.0/vars
. /etc/openvpn/easy-rsa/2.0/clean-all
# The following lines are from build-ca. I don't use that script directly
# because it's interactive and we don't want that. Yes, this could break
# the installation script if build-ca changes in the future.
export EASY_RSA="${EASY_RSA:-.}"
"$EASY_RSA/pkitool" --initca $*
# Same as the last time, we are going to run build-key-server
export EASY_RSA="${EASY_RSA:-.}"
"$EASY_RSA/pkitool" --server server
# Now the client keys. We need to set KEY_CN or the stupid pkitool will cry
export KEY_CN="$CLIENT"
export EASY_RSA="${EASY_RSA:-.}"
"$EASY_RSA/pkitool" $CLIENT
# DH params
. /etc/openvpn/easy-rsa/2.0/build-dh
# Let's configure the server
cd /usr/share/doc/openvpn/examples/sample-config-files
gunzip -d server.conf.gz
cp server.conf /etc/openvpn/
cd /etc/openvpn/easy-rsa/2.0/keys
cp ca.crt ca.key dh2048.pem server.crt server.key /etc/openvpn
cd /etc/openvpn/
# Set the server configuration
sed -i 's|dh dh1024.pem|dh dh2048.pem|' server.conf
sed -i 's|;push "redirect-gateway def1 bypass-dhcp"|push "redirect-gateway def1 bypass-dhcp"|' server.conf
sed -i "s|port 1194|port $PORT|" server.conf
# Obtain the resolvers from resolv.conf and use them for OpenVPN
cat /etc/resolv.conf | grep -v '#' | grep 'nameserver' | grep -E -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | while read line; do
sed -i "/;push \"dhcp-option DNS 208.67.220.220\"/a\push \"dhcp-option DNS $line\"" server.conf
done
# Listen at port 53 too if user wants that
if [ $ALTPORT = 'y' ]; then
iptables -t nat -A PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-port $PORT
sed -i "/# By default this script does nothing./a\iptables -t nat -A PREROUTING -p udp -d $IP --dport 53 -j REDIRECT --to-port $PORT" /etc/rc.local
fi
# Enable net.ipv4.ip_forward for the system
sed -i 's|#net.ipv4.ip_forward=1|net.ipv4.ip_forward=1|' /etc/sysctl.conf
# Avoid an unneeded reboot
echo 1 > /proc/sys/net/ipv4/ip_forward
# Set iptables
iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -j SNAT --to $IP
sed -i "/# By default this script does nothing./a\iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -j SNAT --to $IP" /etc/rc.local
# And finally, restart OpenVPN
/etc/init.d/openvpn restart
# Let's generate the client config
mkdir ~/ovpn-$CLIENT
# Try to detect a NATed connection and ask about it to potential LowEndSpirit
# users
EXTERNALIP=$(wget -qO- ipv4.icanhazip.com)
if [ "$IP" != "$EXTERNALIP" ]; then
echo ""
echo "Looks like your server is behind a NAT!"
echo ""
echo "If your server is NATed (LowEndSpirit), I need to know the external IP"
echo "If that's not the case, just ignore this and leave the next field blank"
read -p "External IP: " -e USEREXTERNALIP
if [ $USEREXTERNALIP != "" ]; then
IP=$USEREXTERNALIP
fi
fi
# IP/port set on the default client.conf so we can add further users
# without asking for them
sed -i "s|remote my-server-1 1194|remote $IP $PORT|" /usr/share/doc/openvpn/examples/sample-config-files/client.conf
cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf ~/ovpn-$CLIENT/$CLIENT.conf
cp /etc/openvpn/easy-rsa/2.0/keys/ca.crt ~/ovpn-$CLIENT
cp /etc/openvpn/easy-rsa/2.0/keys/$CLIENT.crt ~/ovpn-$CLIENT
cp /etc/openvpn/easy-rsa/2.0/keys/$CLIENT.key ~/ovpn-$CLIENT
cd ~/ovpn-$CLIENT
sed -i "s|cert client.crt|cert $CLIENT.crt|" $CLIENT.conf
sed -i "s|key client.key|key $CLIENT.key|" $CLIENT.conf
tar -czf ../ovpn-$CLIENT.tar.gz $CLIENT.conf ca.crt $CLIENT.crt $CLIENT.key
cd ~/
rm -rf ovpn-$CLIENT
echo ""
echo "Finished!"
echo ""
echo "Your client config is available at ~/ovpn-$CLIENT.tar.gz"
echo "If you want to add more clients, you simply need to run this script another time!"
fi

“Happy tunneling

Bonus: Para los que os guste un poco más el heavy metal aquí un tutorial paso a paso con explicaciones más detalladas.