Archivo de la categoría: Manual

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.

Cómo forzar WordPress para que use un certificado SSL gratis mediante un plugin

En los posts anteriores hemos instalado WordPress y hemos alojado varios sitios en un mismo servidor. En este post lo que haremos será mejorar la seguridad de nuestro blog y las SERPs en Google. Hace ya un tiempo Google recomendó a los webmasters dejar de usar http y pasar a https para hacer la web más segura. Para forzar un poco el brazo Google ofreció mejoras en los rankings a aquellas webs que usaran un certificado SSL. Como no es fácil para todos los bloggers comprar un certificado SSL lo que propongo es obtener gratuitamente un certificado de SSL gracias a cloudflare y así poder ofrecer nuestro blog de forma más segura para los usuarios.  Para conseguirlo solo tenemos que seguir los siguientes pasos.

Instalar el plugin para el certificado SSL en wordpress

Para instalar el plugin WordPress podemos ir al apartado de plugins y buscar “WordPress HTTPS” e instalarlo usando el panel de control. También podemos instalarlo manualmente mediante FTP, subiéndolo directamente a la carpeta de /wp-content/plugins/ e instalándolo como cualquier otro complemento. Una vez instalado lo activaremos.

Conseguir el certificado SSL gratis

La mayoría de certificados son de pago pero cloud cloudflare fare nos permite usar un certificado SSL gratis para proyectos más modestos. Lo único que tenemos que hacer es registrarnos y añadir la página web cuando nos la pidan. Finalmente cambiaremos los name servers en nuestro registrador de dominios.

Actualizar los ficheros de configuración de WordPress

Finalmente iremos a ajustes generales en la sección de ajustes de nuestro blog wordpress y cambiaremos http por https dejando el resto de la url intacta. Por algún motivo que desconozco he tenido que cambiar el fichero wp-config.php. Justo antes de /* That’s all, stop editing! Happy blogging. */ he tenido que añadir

define('FORCE_SSL_ADMIN', false);

para poder acceder al wp-admin.

Espero que esto os haya servido para mejorar la seguridad del blog y los rankings de las SERPs.

Instalar WordPress en un servidor propio

Como ya vimos el otro día, podemos alojar varios sitios web en un mismo servidor. En mi caso para lo que los quería era para instalar distintas instancias de WordPress (osease distintos blogs). Pero para usar WordPress requerimos distintas aplicaciones para las diferentes partes del sistema.

PHP

Primero instalaremos PHP para que los scripts de WordPress puedan ser ejecutados.

sudo apt-get install php apache2 libapache2-mod-php php-mcrypt php-mysql

Base de datos

Ahora instalaremos la base de datos

sudo apt-get install mysql-server
 sudo mysql_secure_installation
 sudo mysql_install_db

y crearemos los usuarios para cada uno de nuestro blog. Primero nos logearemos como root para poder crear usuarios

mysql -u root -p

crearemos el usuario

GRANT ALL PRIVILEGES ON *.* TO 'user'@'localhost' IDENTIFIED BY 'pass';

Saldremos de la conexión con la base de datos con el root, y nos logearemos con el nuevo usuario

 mysql -u user -p

y crearemos una nueva base de datos para el blog

CREATE DATABASE db_wordpress;

Scripts de WordPress

Nos bajaremos la última versión de WordPress. La descomprimiremos y la pondremos en /var/www/directorio-de-tu-blog/. Para terminar de configurar el apache podéis seguir esta guía.

Finalizar

Para finalizar y que los cambios tengan efecto reiniciaremos apache

sudo systemctl restart apache2
 apt-cache search php- | less

y accederemos a la url de nuestro blog. Allí se nos pedirá que ingresemos los datos de la base de datos y otra información básica sobre el blog.

Optimizadores de tensor flow

Continuando el anterior post dónde introducí tensor flow hoy vengo con los optimizadores de funciones. Tensor flow ofrece optimizadores que cambian las variables para minimizar la funcion de perdida (loss function). El más simple es el de gradiente descendiente. Computan las derivadas simbólicas (symbolic derivatives) simplemente usando el modelo y la función tf.gradients. Por ejemplo:

optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
print(sess.run([W, b]))
los resultados finales
[array([-0.9999969], dtype=float32), array([ 0.99999082],
dtype=float32)]

El modelo completo para la regresión linal es:

import numpy as np
import tensorflow as tf
# Model parameters
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # suma de los cuadrados
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x:x_train, y:y_train})
# evaluate training accuracy
curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
# When run, it produces
#W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

tf.contrib.learn te simplifica la vida con las funciones: ejecución, entrenamiento, iteraciones, evaluaciones entre otros

import tensorflow as tf
import numpy as np
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
num_epochs=1000)
estimator.fit(input_fn=input_fn, steps=1000)
print(estimator.evaluate(input_fn=input_fn))
# Result: {'global_step': 1000, 'loss': 1.9650059e-11}

Introducción a TensorFlow

La web oficial de TensorFlow tiene muy buenos recursos. En esencia lo que hay en este post proviene del “get started” de la web oficial.

En el primer ejemplo importaremos TensorFlow. Crearemos dos constantes y las imprimiremos en pantalla.

import tensorflow as tf
node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # También tf.float32 de forma implícita
sess = tf.Session()
print(sess.run([node1, node2]))
node3 = tf.add(node1, node2)
print("node3: ", node3) #Esta linea muestra las propiedades del tensor
print("sess.run(node3): ",sess.run(node3)) # Aquí se imprime el resultado

También podemos aplicar operaciones a los tensors. Las operaciones producen más tensores. En el siguiente ejemplo sumamos dos variables (tensores) y luego las sumamos. Un tensor es capaz de procesar listas también como veremos.

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b
print(sess.run(adder_node, {a: 3, b:4.5})) # 7.5
print(sess.run(adder_node, {a: [1,3], b: [2, 4]})) # Itera sobre la lista: 3 y 7

Podemos multiplicar

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

E incluso podemos crear modelos lineales

W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

Las constantes son inicializadas con tf.constant, y su valor no puede ser cambiado. Contrariamente las variables son creadas usando tf.Variable y no son inicializadas en el inicio. Para inicializar las variables  tenemos que usar una función especial como en el siguiente ejemplo:

init = tf.global_variables_initializer()
sess.run(init)

Lo importante es usar init. Es un “handle” que inicia el grafo, inicializando las variables que hasta entonces habían permanecido sin inicializar.

Ya que la X es la variable podemos evaluar el modelo usando distintos valores simultáneamente de la siguiente manera:

print(sess.run(linear_model, {x:[1,2,3,4]}))
# Output: [ 0, 0.30000001, 0.60000002, 0.90000004]

La función de pérdida (loss function) puede medir la distancia entre el modelo actual y los datos proporcionados. Usaremos la función de pérdida estándar para hacer una regresión lineal que sume los cuadrados de las distancias entre el modelo actual y los datos. El modelo crea un vector en el que cada posición corresponde a una distancia de error. Cuando usamos tf.square estamos elevando al cuadrado el error. Luego sumamos los errores para crear un simple escalar que abstrae el error de todos los puntos usando tf.reduce_sum:

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

El valor producido es:  23.66

Podríamos mejorar el modelo manualmente asignando nuevos valores a W para obtener resultados perfectos de -1 y 1. Una variables es inicializada por el valor proporcionado por tf.Variable pero puede ser cambiada si usamos operaciones como tf.assign. Por ejemplo, W=-1 y b=1 son los parámetros óptimos de nuestro modelo. Podemos cambiar W y b acordemente:

fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]})
#resultado: 0

Hemos adivinado el valor perfecto para W i b aunque este no es el objetivo de  machine learning. El objetivo es encontrar los parámetros correctos para el modelo automáticamente. Pero esto lo vais a encontrar en la próxima entrega 😉

Bonus: En matemáticas y en física, un tensor es cierta clase de entidad algebraica de varias componentes, que generaliza los conceptos de escalar, vector y matriz de una manera que sea independiente de cualquier sistema de coordenadas elegido. ( wikipedia )

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)

Generar una barra de progreso en ipython notebooks

Manual con código para generar una barra de progreso en nuestro código para saber en que porcentaje de compleción estamos sin llenar el output con números. Muchos de los que usáis jupyter (el nuevo ipython notebooks) podéis imprimir por pantalla la iteración en la que vuestro loop reside. Eso es solo posible para una cantidad pequeña de iteraciones. Cuando llegamos a varios miles se puede generar un output bastante engorroso. Googleando un poco encontré la solución. Este código nos genera una clase que luego podemos llamar para obtener la barra de progreso junto con el porcentaje completado.

import sys, time
try:
    from IPython.core.display import clear_output
    have_ipython = True
except ImportError:
    have_ipython = False

class ProgressBar:
    def __init__(self, iterations):
        self.iterations = iterations
        self.prog_bar = '[]'
        self.fill_char = '*'
        self.width = 40
        self.__update_amount(int(0))
        if have_ipython:
            self.animate = self.animate_ipython
        else:
            self.animate = self.animate_noipython

    def animate_ipython(self, iter):
        try:
            clear_output()
        except Exception:
            # terminal IPython has no clear_output
            pass
        print '\r', self,
        sys.stdout.flush(),
        self.update_iteration(iter + 1)
        
    def update_iteration(self, elapsed_iter):
        self.__update_amount((elapsed_iter / float(self.iterations)) * 100.0)
        self.prog_bar += '  %d of %s complete' % (elapsed_iter, self.iterations)

    def __update_amount(self, new_amount):
        percent_done = int(round((new_amount / 100.0) * 100.0))
        all_full = int(self.width - 2)
        num_hashes = int(round((percent_done / 100.0) * all_full))
        self.prog_bar = '[' + self.fill_char * num_hashes + ' ' * (all_full - num_hashes) + ']'
        pct_place = int((len(self.prog_bar) / 2) - len(str(percent_done)))
        pct_string = '%d%%' % percent_done
        self.prog_bar = self.prog_bar[0:pct_place] + \
            (pct_string + self.prog_bar[pct_place + len(pct_string):])

    def __str__(self):
        return str(self.prog_bar)
        

Y el siguiente código vemos un ejemplo de como llamaremos la clase para obtener la funcionalidad deseada

c = ProgressBar(1000)
for i in range(1000):
    c.animate_ipython(i)

Para los interesados encontré el código aquí.

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.

 

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.