Actualizado el 26 de Septiembre de 2022

Para configurar una Raspberry Pi y que funcione como servidor de música usando una cuenta de Spotify usaremos el paquete mopidy. Existen distribuciones ya preparadas con el servidor de música configurado pero en este caso estas instrucciones son para hacerlo sobre una distribución ya existente.

Primero hay que agregar el repositorio de mopidy y para ello primero agregamos las claves:
wget -q -O – https://apt.mopidy.com/mopidy.gpg | sudo apt-key add –

Ahora el repositorio (en este caso para una distribución jessie, habría que cambiar por la que corresponda):
sudo wget -q -O /etc/apt/sources.list.d/mopidy.list https://apt.mopidy.com/jessie.list

A continuación actualizar e instalar:

sudo apt-get update
sudo apt-get install python-spotify

Ahora instalamos el paquete de Spotify, según la página solo funciona para cuentas premium aunque hay gente que comenta que lo ha usado también para cuentas gratuitas:
sudo python3 -m pip install Mopidy-Spotify

Existen varias formas de arrancarlo, vamos a optar por hacerlo como servicio. Con este comando lo arrancaremos al inicio como servicio:
sudo systemctl enable mopidy

Otra opción para sistemas Debian es:
sudo dpkg-reconfigure mopidy

Estos son los clásicos comandos para arrancar, parar y reiniciar:

sudo service mopidy start
sudo service mopidy stop
sudo service mopidy restart

Ahora solo queda configurar el servidor web, viene instalado por defecto y lo configuramos en la siguiente ruta:
sudo nano /etc/mopidy/mopidy.conf

Creamos una sección [http]

[http]
enabled = true
hostname = ::
port = 6680

Lo único destacable aquí es que el nombre de host es «::» esto indica que escuchará en todas las direcciones IP, no hay validación de usuario así que cualquiera podrá acceder.

Y una sección para el usuario y contraseña de Spotify , los datos de client_id y client_secret se pueden obtener aquí.

username = hola
password = caracola
client_id = XXX
client_secret = YYY

Ahora si intentamos acceder al servidor y al puerto nos dirá que no hay cliente web instalado, existen varias alternativas.

Para poder instalar estos paquetes primero hay que instalar pip, un instalador de paquetes en Python:
sudo apt-get install python-pip

En este caso opto por Mopify y se instala con:
sudo pip install Mopidy-Mopify

Y en el fichero de configuración añadimos

[mopify]
enabled = true
debug = false

Si lo queremos actualizar:
sudo pip install –upgrade Mopidy-Mopify

También existe este otro cliente, más parecido a la interfaz de Spotify y más sencillo:
sudo pip install Mopidy-Iris

Para actualizar
sudo pip install –upgrade Mopidy-Iris

Y como configuración

[iris] 
enabled = true 
country = ES 
locale = es_ES

Es necesario reiniciar el servicio para ver los cambios, al acceder al servidor (http://servidor:6680) veremos el cliente.

Si queremos comprobar primero que el sonido está bien configurado podemos usar este comando:
aplay /usr/share/sounds/alsa/Front_Center.wav

Se pueden cambiar la salida de audio usando raspi-config (System->Audio)  o de forma manual junto con algunas otras opciones con alguno de estos dos métodos dependiendo de la versión:

Versión antigua

Usar HDMI si está conectado, sino jack de 3.5» (si este comando da un error probar con la versión nueva):
sudo amixer cset numid=3 0

Forzar usar solo jack de 3.5:
sudo amixer cset numid=3 1

Forzar usar solo HDMI:
sudo amixer cset numid=3 2

Para controlar el volumen se puede poner estos alias en ~/.bashrc
# Increase volume by 5%
alias volu=’amixer set PCM — $[$(amixer get PCM|grep -o [0-9]*%|sed ‘s/%//’)+5]%’
# Decrease volume by 5%
alias vold=’amixer set PCM — $[$(amixer get PCM|grep -o [0-9]*%|sed ‘s/%//’)-5]%’

O establecer directamente el valor con (donde 90% es el volumen deseado):
amixer sset PCM,0 90%

Version nueva

Para cambiar las opciones de audio hay que editar el fichero .asoundrc que tendremos en el directorio home del usuario, también podemos guardarlo en la ruta /etc/asound.conf en cuyo caso será para todos los usuarios, sino lo tenemos lo creamos:

pcm.!default {
  type asym
  playback.pcm {
    type plug
    slave.pcm "output"
  }
  capture.pcm {
    type plug
    slave.pcm "input"
  }
}

pcm.output {
  type hw
  card 0
}

ctl.!default {
  type hw
  card 0
}

Donde indica card 0 si ponemos card 1 usaremos la salida Headphones sino card 0 usará HDMI después de crear este fichero hay que reiniciar la sesión usando su pi si no lo hemos hemos en /etc/asound.conf

Para controlar el volumen se puede poner estos alias en ~/.bashrc, este ejemplo es para el jack de 3.5» sino se ha establecido la salida de jack usando el fichero anterior este comando dará error (igual para HDMI).
# Increase volume by 5%
alias volu=’amixer set Headphone — $[$(amixer get Headphone|grep -o [0-9]*%|sed ‘s/%//’)+5]%’
# Decrease volume by 5%
alias vold=’amixer set Headphone — $[$(amixer get Headphone|grep -o [0-9]*%|sed ‘s/%//’)-5]%’

Para HDMI haríamos:
# Increase volume by 5%
alias volu=’amixer set HDMI — $[$(amixer get HDMI |grep -o [0-9]*%|sed ‘s/%//’)+5]%’
# Decrease volume by 5%
alias vold=’amixer set HDMI — $[$(amixer get HDMI |grep -o [0-9]*%|sed ‘s/%//’)-5]%’

O establecer directamente el valor con (donde 90% es el volumen deseado) para el jack de 3.5»
amixer sset Headphone,0 90%

O para HDMI
amixer sset HDMI,0 90%

Acceso a la Web

Ahora solo queda acceder a la web con la ip y puerto configurado y elegir el cliente, es posible que haya que echar un vistazo a la configuración del cliente para ver que todo está correcto como dar acceso a spotify.

A veces el refresco de algunas playlist no funciona correctamente y puede ser necesario borrar cookies o recargar la página, se puede probar desde otra máquina para verificar si realmente refresca o no.

Ahora vamos a ver como configurar estas rutas por algo más fácil de recordar, para ello en Apache creamos un virtual host que nos haga de proxy con el servidor de spotify, creamos un fichero en la carpeta /etc/apache2/sites-available/003-spotify.conf con el siguiente contenido, obviamente deberemos tener un sistema DNS que nos resuelva correctamente el nombre spotify, vamos a suponer que el servidor está en la dirección 192.168.1.4

<VirtualHost spotify:80>
  ServerName spotify.domain
  SererAlias spotify
  ProxyPreserveHost On
  ProxyPass / http://192.168.1.4:6680/
  ProxyPassReverse / http://192.168.1.4:6680/
  CustomLog /var/log/apache2/spotify.log combined
  ErrorLog /var/log/apache2/spotify.error.log
</VirtualHost>

Para habilitar el sitio ejecutamos:

sudo a2ensite 004-spotify.conf

Fuentes:

https://github.com/mopidy/mopidy-spotify

https://www.mopidy.com/

Ahora que tenemos el entorno vamos a descargar los fuentes en la carpeta, evidentemente la carpeta donde desplegamos tiene que estar configurada en Apache, nos colocamos en la carpeta de despliegue y lanzamos un git clone, en este caso suponemos un hosting en BitBucket que nos descargará todo el código.

# git clone https://usuario@bitbucket.org/acme/coyote.git

Siguiendo los consejos de Symfony2 vamos a verificar que está todo correcto, para esto primero tenemos que instalar composer y que nos ponga al día todos los paquetes, es recomendable tener accesible el fichero composer.json para evitar tener que repetir configuraciones.

# sudo curl -sS https://getcomposer.org/installer | sudo php
# sudo php composer.phar install --no-dev --optimize-autoloader

El fichero composer.json tiene que estar accesible en la misma ruta ya que es el fichero que usará para descargar los paquetes correctos.

Puede dar un error de «ErrorException: proc_open(): fork failed – Cannot allocate memory» una forma de arreglarlo es crear una unidad swap con los siguientes comandos:

# sudo /bin/dd if=/dev/zero of=/var/swap.1 bs=1M count=1024
# sudo /sbin/mkswap /var/swap.1
# sudo /sbin/swapon /var/swap.1

Es recomendable que el fichero parameters.yml esté fuera del código fuente pero es necesario mantener parameters.yml.dist ya que en esta es donde se establecen los nuevos parámetros con sus valores por defecto. Después de esto los valores concretos de los parámetros se podrán modificar en parameteres.yml.

Es necesario una vez que se descarga la nueva versión desde git limpiar la cache y establecer de nuevos los permisos en la cache, para todos estos procesos se puede usar el siguiente script ubicándolo en la localización correcta.

# sudo git pull
# sudo php app/console cache:clear --env=prod
# sudo chown -R www-data:coyote app/cache

Cada vez aparecen más microdispositivos que ofrecen un buen rendimiento a bajo coste, uno de estos es raspberry pi (con papel estelar en la serie Mr. Robot), tiene múltiples posibilidades por ejemplo servir como VPN, servidor DHCP, DNS,… o servidor multimedia (con Torrent).

En este caso vamos a instalar un servidor LAMP de desarrollo usando la distribución Raspbian, Raspbian es muy fácil de instalar usando el sistema NOOBS tal y como se comenta en la propia página web, de hecho si solo queremos un servidor es muy recomendable instalar la versión lite que nos quitará el apartado gráfico.

Después de instalar tendremos un menú donde podremos modificar algunos valores, si queremos volver a invocarlo siempre podremos hacerlo a través de raspi-config (si hemos usado usado la versión lite tendremos que instalar este paquete vía sudo apt-get install rpi-update).

Una vez arrancado el sistema es recomendable actualizarlo, tanto el firmware del mismo a través de rpi-update (requiere reiniciar) como los paquetes a través de apt-get update && apt-get-upgrade.

Ya que vamos a instalar un servidor suele ser recomendable tener una dirección IP estática, para eso editaremos el archivo /etc/network/interfaces y en lugar de usar una dirección dinámica (DHCP) indicaremos los datos de nuestra interfaz, existe un artículo describiendo el proceso y nos quedará para la interfaz eth0 algo como:

iface eth0 inet static
address 192.168.1.3
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1

Otra opción sería dejarlo en dinámico (con DHCP) y establecer en los servidores DHCP y DNS el nombre de manera estática, esto simplifica la gestión de red de las raspberry pero obliga a tener un servidor DHCP y DNS instalado.

Tras esto hay que tirar y levantar la interfaz vía ifdown eth0 &&  service networking restart && ifup eth0, tambien  es recomendable hacerlo por consola por si la interfaz no se levanta, si sale un error como ifdown: interface eth0 not configured, una opción es lanzar este comando y reiniciar la raspberry.

sudo ip addr flush dev eth0

Opcionalmente podemos querer cambiar el nombre de la raspberry esto lo haremos modificando el fichero /etc/hostname, si se cambia el nombre por defecto para el correcto descubrimiento de la propia raspberry hay que modificar también el fichero /etc/hosts.

Tras esto instalamos el entorno con: apt-get install apache2 php5 mysql-server en el caso de mysqlserver nos solicitará una contraseña de root para poder acceder al servidor, no es obligatorio pero si muy recomendable.

Suele ser útil crear un host virtual en apache en el cual indicaremos que las páginas PHP que ejecuta están almacenados en una unidad de red externa, de esta forma podremos editarlos desde otra máquina a la vez que se pueden acceder desde Apache, para esto podremos usar el host virtual por defecto que viene en la instalación, es más útil trabajar con virtuales porque así podemos aislar proyectos entre sí con sus propios nombres.

Solo hay que tener en cuenta que dentro del host virtual hay que añadir ServerName servidor donde servidor será el nombre que le hayamos dado al servidor virtual, aquí hay un trabajo con el DNS ya que por un lado en el propio archivo hosts del servidor tenemos que darlo de alta y de cara al exterior también tendremos que darlo de alta en el archivo hosts de cada máquina que quiera acceder a no ser que dispongamos de un servidor DNS a tal efecto.

Para mapear las carpetas de apache a una unidad de red solo tenemos que montar la unidad (mount -a) de red externa añadiéndolo a /etc/fstab tal que (en una línea):

//unidad/carpeta/cliente/proyecto /var/www/proyecto/  cifsuid=1000,gid=1000,username=user,password=pass,iocharset=utf8,auto 0 0

donde username y password son credenciales válidas de red, también se puede especificar un fichero externo de credenciales, para más información consultar man.

Una vez hecho esto ya podemos desarrollar, también podemos clonar un repositorio Git en la carpeta, por ejemplo Bitbucket que permite repositorios privados y también es compatible con Azure, aunque GitHub también es otra posibilidad.