Acceso mediante SSH sin contraseña

Una de las cosas que más veces he tenido que hacer, dado que soy un forofo de la automatización, es poder entrar desde una máquina a otra de forma automática.

SSH

El protocolo SSH (Secure SHell) nos permite entrar en una máquina remota de forma segura (a diferencia de su hermano mayor, telnet) mediante una línea de comandos sobre una red no necesariamente segura.

Los datos que se envían y se reciben por medio de este protocolo se encriptan mediante un par de claves pública y privada, de manera que aunque alguien “esnife” nuestra red, no podrá interpretar qué comandos estamos lanzando ni qué resultados nos devuelve la máquina remota.

Para conectar desde una máquina A a otra máquina B, necesitamos en A un cliente de SSH y en B un servicio de servidor de SSH. Si nuestros sistemas no traen de serie estas utilidades, deberíamos poder instralarlas mediante el correspondiente sistema de paquetes (openssh-client y openssh-server respectivamente).

Normalmente, accederemos a la máquina remota de forma interactiva, tecleando un usuario y una contraseña, de la misma manera que lo haríamos si utilizásemos una consola local en dicha máquina. Para ello, lógicamente, deberemos utilizar las credenciales de un usuario existente.

Automatización

Pero ¿qué pasa si lo que queremos es entrar de forma “no interactiva” en la máquina remota?. SSH nos obliga siempre a teclear al menos una contraseña, aunque podemos evitar teclear el usuario de la siguiente forma:

$ ssh usuario@maquinaremota

La única solución viable que tenemos es utilizar claves criptográficas en lugar de usuarios para acceder. El principio es el siguiente:

1. En la máquina A nos creamos una pequeña infraestructura PKI con un par de claves: privada y pública.
2. Compartimos con la máquina B nuestra clave pública.
3. Accedemos de A a B encriptando ciertos datos por medio de nuestra clave privada.
4. La máquina B intenta desencriptar mediante la clave pública que le proporcionamos inicialmente los datos que acabamos de encriptar por medio de nuestra clave privada.
5. Si la desencriptación tiene éxito, se nos concede el acceso.

Secuencia

Esta forma de acceder mediante ssh está ampliamente documentada literalmente en miles de páginas de internet, pero de lo que se trata es de tener un pequeño “chuletario” rápido para tenerlo aquí para cuando nos haga falta.

La secuencia de comandos a utilizar, suponiendo que estamos en una máquina A y queremos acceder a otra máquina remota B, es la siguiente:

1. Generar una pareja de claves criptográficas.
   En la máquina A generamos un par de claves con el siguiente comando:

   $ ssh-keygen -t rsa
   

   El comando tardará un rato en generar el par de claves y nos pedirá dos veces que especifiquemos una contraseña, que dejaremos en blanco (pulsando enter) ambas veces.
   El parámetro -t especifica el tipo de encriptación que utilizaremos. Pueden ser otros como dsa, ecdsa, etc, pero lo más normal es utilizar rsa.
   Este comando nos va a crear en el directorio home del usuario actual (/home/usuario en caso de un usuario normal o /root en caso del usuario superadministrador) un directorio oculto de nombre .ssh con el siguiente contenido:

   id_rsa
   id_rsa.pub
   

   El primero es nuestra nueva clave privada, y el segundo la clave pública. Ambas claves criptográficas nos permiten cifrar con una y descifrar con la otra.
2. Copiar la clave pública.
   Nuestra clave privada permanecerá siempre guardada en nuestra máquina A, pero la pública tenemos que trasladarla a la máquina de destino a la que querremos conectar.
   Para ello, primero haremos lo siguiente:

   $ ssh usuarioB@maquinaB
   

   Con esto estamos accediendo a la máquina B con el usuario usuarioB de forma interactiva. Se nos pedirá la contraseña del usuarioB y a continuación nos aseguraremos de que tenemos un directorio .ssh en su home:

   $ mkdir .ssh
   $ chmod 700 .ssh
   $ exit
   

   Una vez creado el directorio (hemos vuelto a A con el exit), copiamos nuestra clave pública concatenándola con lo que haya en el fichero authorized_keys de dicho directorio de B:

   $ cat id_rsa.pub | ssh usuarioB@maquinaB 'cat >> .ssh/authorized_keys'
   

   Este fichero contendrá todas las claves públicas autorizadas a entrar en esta máquina y este usuario sin contraseña.
3. Entrar sin contraseña.
   Una vez que hemos hecho lo anterior, ya podemos entrar desde A a B utilizando de nuevo el sigiuiente comando:

   $ ssh usuarioB@maquinaB
   

A partir de ahora ya no nos pedirá contraseña.

Instalación de HomeAssistant mediante PyEnv

Cuando uno empieza a entrar en el mundo de la domótica “casera” (nunca mejor dicho), no a base de utilizar productos comerciales sino haciéndolo todo uno mismo, lo primero que piensa es en la Raspberry Pi.

Yo, sin embargo, en mi afán de gastar lo mínimo posible comprando productos en China, decidí en un principio utilizar la Orange Pi Zero como mi controlador principal para HomeAssistant, como vimos en un artículo anterior.

Problemática

En realidad, uno puede instalar HomeAssistant en cualquier ordenador o controlador: un equipo Mac, Windows, Linux, un core I7 de última generación o un ARM con 256 MB de RAM, siempre y cuando sea posible instalarle Python.

Sin embargo, apartarse del estándar utilizado por la mayoría tiene su penalización.

Si tienes una Raspberry PI, basta con acudir a la página de HomeAssistant y bajarte una distribución de Linux especial personalizada (hass.io o hassbian) y grabarla en tu tarjeta SD para salir andando. Ambas distribuciones están pensadas para que el usuario trabaje lo mínimo, sea fácil actualizar, esté todo optimizado, etc.

Pero ¿qué pasa cuando tu distribución, que no es la estándar, se queda anticuada y los requerimientos de versiones de HomeAssistant van subiendo y no tienes posibilidad de actualizar?. De todos es sabido que las distribuciones de Linux tienen una gran ventaja que son los repositorios de software (debian, ubuntu, rpm, etc) desde los que el usuario siempre puede instalarse el software sin tener que buscar en ningún sitio más. Esta gran ventaja sin embargo se convierte en un gran inconveniente cuando los paquetes del repositorio se quedan antiguos y no se pueden actualizar más.

Tal es el caso de la Orange Pi Zero, para la cual disponemos de varias versiones (aquí y aquí) de Linux pero todas ellas basadas en un repositorio de Debian que no es el más nuevo.

Esto es un problema cuando los requerimientos de HomeAssistant subieron por ejemplo de Python 3.4 a Python 3.5.3. Este cambio que en principio puede parecer mínimo hace que por ejemplo en la versión de Ubuntu 16.04.04 LTS que es la que yo uso no pueda instalar versiones recientes de HomeAssistant puesto que la versión máxima de Python que hay en los repositorios es la 3.5.2. Lo mismo nos pasaría si tuviésemos un Debian Jessie que no podamos actualizar.

Por tanto, no podemos utilizar versiones “oficiales” de Python. ¿Qué soluciones nos quedan?

A bote pronto, se me ocurren tres:

• Utilizar un repositorio PPA.
  He consultado varios y o bien no contienen software para procesadores ARM o bien no funcionan con mi distribución.
• Compilar Python 3.5. desde *código fuente.
  Es una posibilidad, pero bastante engorrosa.
• Utilizar PyEnv.
  Este entorno nos permite tener múltiples instalaciones de Python en paralelo sin interferir con los paquetes “oficiales” del sistema.

Por tanto, elegiremos la tercera opción por ser la menos “invasiva” para no liarla con el sistema.

Guía de instalación

Esta guía está pensada para instalar la última versión de HomeAssistant desde cero, en un sistema (Debian Jessie, Ubuntu 16.04, etc) que no soporte de forma nativa la última versión de Python. En caso de tener ya un sistema con HomeAssistant instalado, habría que saltarse algunos pasos.

Crear el usuario homeassistant

Lo primero que necesitaremos (si no lo tenemos ya) es crear un usuario específico para ejecutar HomeAssistant. En los ejemplos de este artículo lo denominamos homeassistant, pero el nombre es lo de menos.

Para ello, seguiremos los siguientes pasos:

1. Entramos como root en el sistema y creamos un nuevo usuario:

   # adduser homeassistant
   

2. Lo añadimos al grupo sudo:

   # apt-get install sudo
   # usermod -aG sudo homeassistant
   

Instalar PyEnv

PyEnv nos permite instalar (compilándola) cualquier versión de python de forma no intrusiva en el sistema,
y nos permite especificar con qué versión queremos trabajar de forma global para todo el sistema o para
una aplicación concreta.

Para instalarlo seguiremos los siguientes pasos:

1. Iniciamos sesión con el nuevo usuario homeassistant.
2. Descargamos pyenv desde su proyecto en GitHub, creando un directorio .pyenv en el home del usuario:

   $ git clone https://github.com/pyenv/pyenv.git .pyenv
   

3. Lo hacemos accesible desde el login, añadiendo al fichero .bashrc las siguientes líneas:

   export PYENV_ROOT="$HOME/.pyenv"
   export PATH="$PYENV_ROOT/bin:$PATH"
   if command -v pyenv 1>/dev/null 2>&1; then
    eval "$(pyenv init -)"
   fi
   

4. Salimos del shell (logout o exit) e iniciamos sesión de nuevo con el usuario homeassistant para que se ejecuten los cambios.
5. Instalamos una serie dependencias necesarias. HomeAssistant requiere en principio compilar python con soporte para SQLite3:

   $ sudo apt-get install libsqlite3-dev
   

6. Instalamos la versión requerida de Python. Lo que hace PyEnv es descargarse los fuentes de la versión requerida de Python y compilarla de forma transparente para el usuario. En este ejemplo instalaremos la versión 3.5.5:

   $ pyenv install 3.5.5
   

7. Establecemos la versión global de python del sistema
   Para ver qué versión de python utiliza el sistema, utilizaremos este comando:

   $ pyenv global
   

   Para ver qué versiones hay instaladas, utilizaremos este otro:

   $ pyenv versions
   

   Para establecer la versión 3.5.5 como global, utilizaremos este:

   $pyenv global 3.5.5
   

Configurar entorno virtual

Una vez que tenemos nuevo python en la oficina, lo más apropiado sería crearnos un entorno virtual para la instalación y ejecución de HomeAssistant.

El entorno virtual nos permite independizar las librerías y ejecutables asociadas a un programa del resto del entorno de python del sistema. Una especie de “caja negra” en la que entraremos cada vez que queramos ejecutar la aplicación.

Para este cometido, existe un plugin para PyEnv que se denomina virtualenv:

1. Instalamos el plugin virtualenv:

   $ git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
   

2. Creamos un entorno virtual de python para HomeAssistant:

   $ pyenv virtualenv 3.5.5 home-assistant
   

   El entorno virtual residirá en el directorio /home/homeassistant/.pyenv/versions/home-assistant
3. Activamos el entorno recién creado:

   $ pyenv activate home-assistant
   

   Tras hacer esto, en el prompt se nos indica el entorno en el que estamos trabajando:

   (home-assistant) homeassistant@mi-servidor:~$
   

   Todos los comandos relativos a python que se ejecuten a partir de ahora sólo afectarán al entorno activo.

Instalar HomeAssistant

Para instalar HomeAssistant en el entorno virtual de Python activo hacemos lo siguiente:

1. Instalar paquetes adicionales:
   Serán necesarios los siguientes paquetes antes de nada:
   
   

   $ sudo apt-get install libssl-dev openssl libmariadb-dev
   $ sudo apt-get install libncursesw5-dev libgdbm-devlibc6-dev
   $ sudo apt-get install libffi-dev zlib1g-dev bzip2 libbz2-dev libreadline-de

2. Instalar librerías necesarias de forma manual. Estas dos librerías nos harán falta para ejecutar HomeAssistant:

   $ pip3 install mysqlclient
   $ pip3 install pyserial
   

3. Instalar el paquete:

   $ pip3 install homeassistant
   

4. Instalar dependencias automáticas:
   Una vez instalado el paquete, lanzaremos el ejecutable por primera vez para que se autoinstalen las dependencias de python adicionales necesarias. Este proceso puede tardar un rato y nos presenta el log por la salida estandar:

   $ hass
   

   Una vez que el proceso ha acabado, podemos probar que todo ha ido bien accediendo mediante un navegador a la siguiente URL:
   http://[DIR_SERVIDOR]:8123
5. Instalar el servicio. Para facilitarnos la vida, vamos a crearnos un servicio para poder iniciar y detener a nuestra voluntad el HomeAssistant. Para ello:
   1. Copiamos el siguiente texto en el fichero /etc/init.d/hass:

      #!/bin/sh
      ### BEGIN INIT INFO
      # Provides:          hass
      # Required-Start:    $local_fs $network $named $time $syslog
      # Required-Stop:     $local_fs $network $named $time $syslog
      # Default-Start:     2 3 4 5
      # Default-Stop:      0 1 6
      # Description:       Home\ Assistant
      ### END INIT INFO
      
      # /etc/init.d Service Script for Home Assistant
      
      RUN_AS="homeassistant"
      export PYENV_ROOT="/home/$RUN_AS/.pyenv"
      HASS_ROOT="$PYENV_ROOT/versions/home-assistant"
      PRE_EXEC="$HASS_ROOT/bin/python3"
      HASS_BIN="$HASS_ROOT/bin/hass"
      PID_DIR="/tmp"
      PID_FILE="$PID_DIR/hass.pid"
      CONFIG_DIR="/var/lib/home-assistant"
      LOG_DIR="/var/log"
      LOG_FILE="$LOG_DIR/hass.log"
      FLAGS="-v --config $CONFIG_DIR --pid-file $PID_FILE --log-file $LOG_FILE --daemon"
      
      start() {
      if [ -f $PID_FILE ] && kill -0 $(cat $PID_FILE) 2> /dev/null; then
        echo 'Service already running' >&2
        return 1
      fi
      echo -n 'Starting service' >&2
      local CMD="$PRE_EXEC $HASS_BIN $FLAGS;"
      su -s /bin/bash --preserve-environment -c "$CMD" $RUN_AS
      if [ $? -ne 0 ]; then
        echo "Failed" >&2
      else
        echo "Done" >&2
      fi
      }
      
      stop() {
      if [ ! -f "$PID_FILE" ] || ! kill -0 $(cat "$PID_FILE") 2> /dev/null; then
        echo 'Service not running' >&2
        return 1
      fi
      echo -n 'Stopping service' >&2
      kill $(cat "$PID_FILE")
      while ps -p $(cat "$PID_FILE") > /dev/null 2>&1; do sleep 1;done;
      rm -f $PID_FILE
      echo 'Done' >&2
      }
      
      install() {
      echo "Installing Home Assistant Daemon (hass)"
      update-rc.d hass defaults
      mkdir -p $CONFIG_DIR
      chown $RUN_AS $CONFIG_DIR
      mkdir -p $LOG_DIR
      chown $RUN_AS $LOG_DIR
      }
      
      uninstall() {
      echo "Are you really sure you want to uninstall this service? The INIT script will"
      echo -n "also be deleted! That cannot be undone. [yes|No] "
      local SURE
      read SURE
      if [ "$SURE" = "yes" ]; then
        stop
        echo "Notice: The config directory has not been removed"
        echo $CONFIG_DIR
        echo "Notice: The log directory has not been removed"
        echo $LOG_DIR
        update-rc.d -f hass remove
        rm -fv "$0"
        echo "Home Assistant Daemon has been removed. Home Assistant is still installed."
      fi
      }
      
      case "$1" in
      start)
        start
        ;;
      stop)
        stop
        ;;
      install)
        install
        ;;
      uninstall)
        uninstall
        ;;
      restart)
        stop
        start
        ;;
      *)
        echo "Usage: $0 {start|stop|restart|install|uninstall}"
      esac
      

   2. Le damos permisos de ejecución:

      $ sudo chmod +x /etc/init.d/hass
      

   3. Iniciamos el servicio, inicializando previamente el fichero de log:

      $ sudo touch /var/log/hass.log
      $ sudo chown homeassistant:homeassistant /var/log/hass.log
      $ sudo service hass start
      

   4. Una vez probado que funciona correctamente (ver el log en /var/log/hass.log), activamos el arranque automático del servicio, bien mediante la herramienta rcconf o bien mediante el propio servicio:

      $ sudo service hass install
      

Configuración

La configuración y el directorio de trabajo configurados por defecto están en la ruta:

/home/homeassistant/.homeassistant

El fichero de configuración principal se denomina configuration.yaml.

Actualizaciones

Con este pequeño tutorial hemos instalado la última versión de HomeAssistant en nuestro sistema. En caso de que aparezcan nuevas versiones, siempre y cuando no aumente la versión requerida de Python, podremos actualizar nuestra instalación siempre de esta manera:

1. Iniciamos sesión con el usuario homeassistant.
2. Activamos el entorno virtual de python:

   $ pyenv activate home-assistant
   

3. Actualizamos a la última versión, deteniendo previamente el servicio e iniciándolo después:

   $ sudo service hass stop
   $ pip3 install --upgrade homeassistant
   $ sudo service hass start
   

Instalar HomeAssistant en Orange Pi Zero

He comenzado a utilizar un proyecto muy interesante para la Orange Pi Zero.

Se trata de Home Assistant, un proyecto de software libre que nos permite tener un sistema centralizado para la domótica de nuestra casa.

Introducción

Home Assistant es un proyecto de software libre, programador en Python, y con una creciente comunidad de aficionados detrás que están desarrollando sus propios componentes para la interconexión de multitud de dispositivos:

• Sensores.
• Interruptores.
• Enchufes.
• Servicios web.
• Comandos de sistema.
• Etc.

Cada componente se enmarca dentro de una categoría, entre las que se destacan las siguientes:

• Sensor. Cualquier cosa capaz de obtener información: sensores de movimiento, sensores de temperatura, estado de un ordenador, velocidad de conexión, información obtenida de una página web, etc.
• Interruptor. Cualquier cosa capaz de cambiar de estado: interruptores eléctricos, encender y apagar ordenadores, activar y desactivar servicios, etc.
• Reproductores multimedia. Cualquier cosa que reproduzca medios: televisores inteligentes, reproductores software, Chromecast, etc.
• Seguimiento de dispositivos. Cualquier cosa que cambie de lugar: posicionamiento GPS, detección por Wifi, por Bluetooth, etc.
• Automatismos. Son reglas que establece el usuario para que ocurran cosas cuando se dan ciertas circunstancias en el resto de elementos: que se enciendan las luces cuando no hay sol, estamos en un rango de horas y hay alguien en casa, que se enciendan cosas cuando un servicio está en un estado.... El límite es la imaginación.

No pretendo dar un curso de HomeAssistant, sino explicar brevemente cómo lo tengo instalado en mi Orange Pi Zero.

Instalación

Home Assistant se puede instalar en cualquier ordenador que tenga Python. No es necesariamente sólo para Linux, se puede instalar también en OSX y en Windows.

Pero el verdadero potencial es que la aplicación no necesita grandes recursos, y podemos aprovechar estos pequeños micro-ordenadores como Raspberry u Orange Pi para montar un servidor dedicado.

Estas son las instrucciones para instalar "Home Assistant" en armbian (distribución de Debian para ARM) en Orange Pi Zero. Casi todo está basado en la documentación "oficial"

https://home-assistant.io/docs/installation/armbian/

aunque con las modificaciones realizadas por mí para que funcione correctamente.

Paso 1:

Instalamos todos los paquetes necesarios si no los tenemos ya:

sudo apt-get update
sudo apt-get install python3-dev python3-pip

Paso 2:

Vamos a ejecutar el programa con un usuario específico, de modo que lo creamos, tanto el usuario como su grupo asociado:

sudo addgroup homeassistant
sudo adduser --system --ingroup homeassistant homeassistant
sudo usermod -G aid_inet homeassistant

El último comando es para que el usuario tenga permitido acceder a internet.

Paso 3:

Creamos un entorno virtual para Python asociado al usuario que hemos creado. De este modo, todos los paquetes instalados sólo afectarán al entorno virtual y no a todo el sistema:

sudo pip3 install --upgrade virtualenv
sudo mkdir /srv/homeassistant
sudo chown homeassistant:homeassistant /srv/homeassistant
sudo mkdir /var/lib/home-assistant
sudo chown -R homeassistant:homeassistant /var/lib/home-assistant

Cambiamos al usuario que acabamos de crear y entramos y ejecutamos el entorno virtual:

sudo su -s /bin/bash homeassistant
virtualenv -p python3 /srv/homeassistant
source /srv/homeassistant/bin/activate

Paso 4:

Instalamos homeassistant con el nuevo usuario que hemos creado y lo configuramos como servicio:

pip3 install --upgrade homeassistant

Ejecutamos por primera vez HomeAssistant para que cree la configuración en el directorio que hemos establecido (/var/lib/home-assistant):

hass --config /var/lib/home-assistant

Una vez que todo ha ido bien, detenemos la ejecución con Ctrl-C.

Paso 5:

Creamos un servicio para ejecutar Home Asistant. El fichero se denominará /etc/init.d/hass y su contenido será el siguiente:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          hass
# Required-Start:    $local_fs $network $named $time $syslog
# Required-Stop:     $local_fs $network $named $time $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       Home\ Assistant
### END INIT INFO

# /etc/init.d Service Script for Home Assistant
# Created with: https://gist.github.com/naholyr/4275302#file-new-service-sh
PRE_EXEC=""
RUN_AS="homeassistant"
BIN="/usr/local/bin/hass"
PID_FILE="/tmp/hass.pid"
CONFIG_DIR="/var/lib/home-assistant"
FLAGS="-v -c $CONFIG_DIR --pid-file $PID_FILE --daemon"
REDIRECT=">> $CONFIG_DIR/home-assistant.log 2>&1"

start() {
  if [ -f $PID_FILE ] && kill -0 $(cat $PID_FILE) 2> /dev/null; then
    echo 'Service already running' >&2
    return 1
  fi
  echo 'Starting service…' >&2
  local CMD="$PRE_EXEC $BIN $FLAGS $REDIRECT"
  su -c "$CMD" $RUN_AS
  echo 'Service started' >&2
}

stop() {
    if [ ! -f "$PID_FILE" ] || ! kill -0 $(cat "$PID_FILE") 2> /dev/null; then
    echo 'Service not running' >&2
    return 1
  fi
  echo 'Stopping service…' >&2
  kill $(cat "$PID_FILE")
  while ps -p $(cat "$PID_FILE") > /dev/null 2>&1; do sleep 1;done;
  echo 'Service stopped' >&2
}

install() {
    echo "Installing Home Assistant Daemon (hass-daemon)"
    echo "999999" > $PID_FILE
    chown $RUN_AS $PID_FILE
    mkdir -p $CONFIG_DIR
    chown $RUN_AS $CONFIG_DIR
}

uninstall() {
  echo -n "Are you really sure you want to uninstall this service? That cannot be undone. [yes|No] "
  local SURE
  read SURE
  if [ "$SURE" = "yes" ]; then
    stop
    rm -fv "$PID_FILE"
    echo "Notice: The config directory has not been removed"
    echo $CONFIG_DIR
    update-rc.d -f hass remove
    rm -fv "$0"
    echo "Home Assistant Daemon has been removed. Home Assistant is still installed."
  fi
}

case "$1" in
  start)
    start
    ;;
  stop)
    stop
    ;;
  install)
    install
    ;;
  uninstall)
    uninstall
    ;;
  restart)
    stop
    start
    ;;
  *)
    echo "Usage: $0 {start|stop|restart|install|uninstall}"
esac

Una vez creado el servicio, hay que darle permisos de ejecución y activarlo al inicio:

sudo chmod +x /etc/init.d/hass
update-rc.d hass defaults

Utilización

Una vez instalado como servicio, podremos iniciar o detener Home Assistant mediante los siguientes comandos:

service hass start
service hass stop

Destacar también que existe un fichero de log en el directorio /var/lib/home-assistant, que sería conveniente por facilidad enlazarlo en el directorio /var/log:

ln -s /var/lib/home-assistant/home-assistant.log /var/log/hass.log

Instalación de componentes adicionales

Home Assistant tal como lo hemos instalado funciona como un servicio aislado que se ejecuta en un entorno virtual de Python.

Cuando activemos en la configuración algún elemento nuevo, todos los componentes necesarios de Python normalmente se instalarán automáticamente en el directorio deps dentro de /var/lib/home-assistant. Esta instalación la realiza directamente el usuario homeassistant.

Si en alguna ocasión la instalación de un componente de Python fallase (cosa que podemos comprobar monitorizando el fichero de log) podemos realizarla a mano ejecutando el entorno virtual, de la siguiente manera:

sudo su -s /bin/bash homeassistant
source /srv/homeassistant/bin/activate
pip3 install COMPONENTE

Y eso es todo por hoy. Espero que os guste.

Orange Pi

Hola otra vez.

Sí, lo sé: hace muchísimo tiempo que no escribo en el blog. Pero ¿qué le voy a hacer?, es que llevo una temporada sin tiempo para nada.

Así que hoy que tengo un ratito voy a poner aquí unos breves apuntes sobre la Orange Pi.

¿Que qué es la Orange Pi?
¿No has oído hablar de la Raspberry Pi? ¿En serio?
¿Ni de cubietruck? ¿Ni de Banana Pi? ¿Ni de Odroid? ¿Ni de Orange Pi?

Raspberry Pi

Bueno, pues todo comenzó en la Universidad de Cambridge (UK) en 2006. En la Facultad de Informática decidieron fabricar un ordenador de reducidas dimensiones en una única placa, que costase poco y que sirviera de "inspiración" a los alumnos para realizar sus propios proyectos. Recuerda un poco en sus orígenes al Arduino, pero a diferencia de aquel, el objetivo era incluir un ordenador completo, no sólo un microcontrolador.

Raspberry Pi 1 Model B

No fue hasta el año 2012 cuando salió a la venta el primer modelo de Raspberry Pi, micro-ordenador del tamaño de una tarjeta de crédito, que fue un verdadero bombazo por su relación calidad-precio. Estas fueron las especificaciones del primer modelo (Raspbery Pi 1 Modelo B):

• Procesador: Broadcom BCM2835. ARMv6 de un sólo núcleo a 700Mhz.
• Gráfica: Broadcom VideoCore 4, capaz de codificar y decodificar 1080p, a 250 Mhz.
• Memoria: 256 MB.
• USB: 2 puertos USB 2.0
• Salida de vídeo: vídeo compuesto y HDMI.
• Salida de audio: minijack y HDMI.
• Almacenamiento: sin almacenamiento interno, con slot para tarjeta SD.
• Red: conector RJ45 a 10/100Mbps
• Otros puertos: 26 pines GPIO (General Purpose Input / Output). Mediante estos pines se pueden implementar protocolos SPI, I2C, I2S, UART, OneWire, etc.

La placa se alimentaba a 5V con un consumo de unos 700 mA, y el precio inicial fue de unas 22£ (unos 35$) más IVA.

Debido al bajo precio de la placa, de la que se han vendido millones de unidades (tanto de los primeros modelos como de los que fueron saliendo después) pronto comenzó a surgir una gran comunidad de usuarios de manera que cualquiera que la compre puede encontrar miles de páginas donde se explica como instalarle cualquier distribución imaginable de Linux: Debian, Raspbian, ArchLinux, OpenElec, Ubuntu, etc.

Además, el bus de conectores GPIO permite la conexión de cualquier dispositivo de la misma manera que lo hacíamos con un Arduino, con la gran ventaja de poder programar en cualquier lenguaje de programación y no estar limitado al C que utliza Arduino ni a su IDE.

El único inconveniente que tiene esta placa es que, a diferencia del Arduino, se trata de un hardware cerrado. Uno puede montarse con cuatro componentes y medio su propio Arduino, hay cientos de fabricantes que lo hacen, diferentes precios, diferentes variantes.... Sin embargo, Raspberry sólo lo fabrica Raspberry, aunque el código fuente sí sea abierto.

Este hecho, y la necesidad de tener más potencia a menos precio, ha provocado que a lo largo de estos años hayan aparecido distintos proyectos que emulan el concepto de Raspberry Pi, pero siempre mejorando en algo: precio, memoria, procesador, etc. Muchos de estos proyectos, además, se han hecho con la intención de que sean compatibles en software (y muchas veces también en hardware) con la placa original, de manera que lo que se puede hacer en una Raspberry se pueda hacer igual en otra placa.

Orange Pi

Y aquí es donde llegamos a hablar de Orange Pi.
Orange Pi es una alternativa barata a Raspberry, tanto de hardware como de software abierto. Esto quiere decir que quien quiera puede construirse su propia placa o comprarla ya hecha a uno de los fabricantes.

Orange Pi PC

Los creadores originales de este micro-ordenador son la empresa china Shenzhen Xunlong Software CO, y dispone de una creciente comunidad de usuarios gracias a sus bajos precios, la disponibilidad de software y una relativa compatibilidad con las Raspberry Pi.

Modelos y características

Hasta la fecha han salido una gran variedad de modelos de este dispositivo, algunas de cuyas características expongo en la siguiente tabla. La mayoría de ellos se basan en el procesador H3 o variantes de la misma marca china: Allwinner. Este tipo de procesadores es muy habitual encontrarlos en multitud de "tablets" y "Android PC" chinos debido a su gran relación potencia-precio.

Modelo	CPU	RAM	Alm.interno	Alm.externo	Red	Vídeo	Conectores
Orange Pi Zero	H2+ (Cortex-A7 cuádruple núcleo)	256MB/512MB	NO	MicroSD hasta 64GB	Ethernet 10/100 + WIFI	Compuesto	Bus 26 GPIO + conector expansión 13 pines + 2 USB 2.0 + USB OTG
Orange Pi One	H3 (Cortex-A7 cuádruple núcleo)	512MB			Ethernet 10/100 + WIFI	HDMI CEC	Bus 40 GPIO + USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi Lite							Bus 40 GPIO + 2 USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi PC		1GB					Bus 40 GPIO + 3 USB 2.0 + USB OTG + conector cámara + infrarrojos + MIC
Orange Pi PC Plus			8GB
Orange Pi PC 2	H5 (Cortex-A53 cuádruple núcleo 64 bit)	1GB			Ethernet 100/1GB + WIFI

Orange Pi Zero

Esta es la pequeña de la familia, el modelo que yo tengo actualmente.
No se trata de una placa muy potente ni tiene unas especificaciones sobresalientes. Además, no está pensada para utilizarla como ordenador de escritorio puesto que no tiene salida HDMI ni VGA.

Sin embargo, para una gran cantidad de aplicaciones, tiene potencia suficiente y además incorpora de serie puertos USB, Wifi y conector de red RJ45. A pesar de que las especificaciones indican que necesita un alimentador de unos 1,5A - 2A yo la tengo funcionando conectada a un puerto USB que supuestamente debería dar unos 500 mA como máximo.

Estas son las ventajas, pero también tiene algunos inconvenientes según mi experiencia:

• El conector GPIO no viene incluído, sino que tienes que soldarlo a la placa o soldar directamente los cables que necesites.
• A pesar de traer WIFI, me ha demostrado que es bastante inestable. Yo particularmente la uso por ethernet y va estupendamente.
• El procesador H2+ se calienta una barbaridad, tanto que si empiezas a pedirle es fácil que se ponga por encima de los 80 grados. Es casi imprescindible ponerle al menos un disipador térmico para que pueda funcionar a unos 60 grados que es algo más tolerable aunque no es lo óptimo.
• La placa tiene salida de vídeo compuesto y posibilidad de tener más puertos USB aparte del que trae soldado y el USB OTG, pero por problemas de espacio no dispone de conectores para ello, sino que tiene un bus de expansión adicional (que sí viene soldado) de 13 pines en los que están disponibles todas estas señales. Venden un adaptador de expansión que se conecta a este bus y nos permite obtener directamente los conectores.

Software

En la página del fabricante disponemos de descargas de varias versiones de Sistemas Operativos para las Orange Pi:

• Ubuntu.
• Debian.
• Raspbian (Distribución Debian específica par Raspberries).
• Armbian (Distribución Debian para dispositivos ARM).
• ArchLinux.
• Android.

También tenemos la página de armbian donde disponemos de las últimas versiones de esta distribución, para varios modelos de Orange Pi y otras placas similares.

Precios

El precio de la Orange Pi Zero, que es la que yo tengo, es muy barato.

A mí me costó US$15.95 (unos 14€) de oferta en Banggood un kit con:

• Orange Pi Zero de 512MB.
• Tarjeta de expansión (con salida de vídeo compuesto y 2 puertos USB adicionales).
• Caja para montaje de ambos elementos.

También podemos encontrarla en Aliexpress  a un precio parecido, por ejemplo en este enlace (16.24$).

De todos modos, a lo mejor comprar la caja es una tontería, dada la temperatura que coge el cacharro estando al aire...

Conclusión

Resumiendo, la placa de la que he hablado hoy es un micro-ordenador muy barato que nos puede servir para hacer muchos proyectos distintos. Podríamos tener distintos servidores preparados y simplemente cambiar de tarjeta SD para cambiar de sistema.

Aunque sus especificaciones no son las mejores del mundo y no tiene una salida HDMI ni VGA (por tanto no es adecuada para montar un ordenador de sobremesa), sí que nos puede servir para montar cualquier servidor que se nos ocurra.

En el siguiente artículo tengo intención de hablar de un proyecto particular de domótica que estoy montando en mi Orange Pi Zero: Home Assistant.

Hasta la próxima.