TI

4147ca3af8bf81f64b5d738c371bfecb_XL

Asterisk en una Raspberry Pi con RasPBX

/ , , , / , , , , , , / 0 comments

Uno de los múltiples usos que le podemos dar a la polivalente Raspberry Pi es montar una centralita telefónica IP (iPBX) para uso domestico o para pequeños negocios. Para ello usaremos RasPBX,  una distribución GNU/Linux basada en Raspbian que incluye Asterisk, FreePBX y otras utilidades y que hace que en pocos minutos y de forma muy sencilla tengamos nuestra iPBX lista para configurar. Tener una centralita telefónica en el hogar puede parecer una tontería salvo que vivamos en una casa muy grande, pero en realidad la telefonía IP nos ofrece diferentes beneficios como la posibilidad de usar nuestro teléfono móvil para hacer y recibir llamadas por usando nuestra línea fija.

El hardware que necesitaremos será:

  • 1 Raspberry Pi 3 Modelo B con su fuente de alimentación
  • 1 Tarjeta MicroSD de 4 o más Gigabytes (yo he usado una SanDisk Ultra de 16GB)
  • 1 Cable HDMI, un monitor con este tipo de entrada y un teclado USB (opcional pero recomendable)
  • 1 Ordenador con un lector de tarjetas SD (para poder preparar la tarjeta)

Los pasos a seguir son:

  1. Preparar la tarjeta SD
  2. Encender la Raspberry Pi
  3. Ajustes básicos
Preparar la tarjeta SD

Las Raspberry Pi arrancan sin una tarjeta SD debidamente formateada y que contenga el bootloader y un sistema operativo. Desgraciadamente preparar dicha tarjeta es algo más complicado que copiar archivos en ella, pero no os preocupéis, veréis que se tratan de unos sencillos pasos. Lo primero es descargar la imagen de RasPBX desde aquí. Nos descargaremos una archivo .zip del que debemos extraer el archivo .img, este es el archivo que usaremos para preparar la tarjeta SD de nuestra Raspberry. Aquí voy a explicar el procedimiento usando un sistema operativo Windows, para otros sistemas podréis encontrar información en este enlace de elinux.org.

Nos descargaremos la utilidad Win32DiskImager desde Sourceforge. Instalamos y ejecutamos dicha utilidad (en función de vuestro ordenador tal vez debáis hacerlo en modo administrador) y aparecerá la siguiente pantalla:

El uso es muy intuitivo: en el campo Image File seleccionamos el archivo de imagen que hemos descargado y en Device la ubicación de la tarjeta SD. Mucho cuidado con que seleccionamos aquí ya que se destruirá el contenido de dicha unidad, así que verificar dos veces que no os estáis equivocando. Después pulsáis en Write y a esperar, si todo va bien tras unos minutos recibiremos un mensaje confirmando que se ha realizado la operación con éxito, con lo que ya tendremos nuestra tarjeta SD lista para usar.

Encender la Raspberry Pi

Introducimos nuestra SD en la Raspberry Pi apagada y a continuación le enchufamos la alimentación y el cable de red. Recomiendo tener un monitor o televisor conectado por HDMI para seguir el proceso de arranque, aunque si estamos usando un ordenador Windows en principio no es necesario siempre y cuando en nuestra red tengamos algún equipo que haga las funciones de servidor DHCP. Si es así la Raspberry obtendrá una dirección IP dinámicamente. Para saber dicha IP tenemos dos métodos:

  • En nuestro Windows abrimos una ventana de terminal (por ejemplo ejecutando cmd), y hacemos ping al host raspbx. Si todo va bien obtendremos respuesta y veremos que IP se le ha asignado. En mi caso es la 192.168.10.115, tal y como podemos ver a continuación.

  • Si hemos conectado un teclado y un monitor, iniciamos sesión con las credenciales root / raspberry. A continuación ejecutamos el comando ifconfig, obtedremos una pantalla como la siguiente donde veremos la dirección IP.

Una vez conocemos la dirección IP ya podemos conectarnos a nuestra Raspberry tanto por SSH para administrar el sistema operativo GNU/Linux como por web para administrar la consola de FreePBX. Las credenciales por defecto son las siguientes:

  • Para el sistema operativo GNU/Linux Raspbian:
    • usuario: root
    • contraseña: raspberry
  • Para la consola de FreePBX:
    • usuario:
    • contraseña:
Ajustes básicos

El siguiente paso es realizar una serie de ajustes básicos. Para ello deberemos conectarnos a la consola del sistema operativo Raspbian, ya sea por SSH o usando un monitor y teclado conectados directamente. Para la conexión SSH a mi me gusta usar MobaXterm, pero el clásico y sencillo Putty también nos servirá.

  1. Expandir la imagen. Si hemos usado una tarjeta MicroSD mayor de 4 GB (en mi caso he usado una de 16), deberemos expandir la imagen ya que en estos momento solo estará ocupando 4GB, independientemente del tamaño de nuestra tarjeta. Para ello debemos ejecutar el comando raspi-config. Nos aparecerá un menú desde el que podremos realizar diferentes ajustes, siendo la primera opción expandir la imagen.

Seleccionamos esta opción y comenzará un proceso que durará unos pocos minutos. Cuando finalice os pedirá que reiniciéis la máquina. Aceptáis y si todo va bien cuando reinicie ya se habrá expandido la imagen. Y digo si todo va bien porque la primera vez se corrompió la imagen y no me cargaba el sistema operativo (en situaciones así ayuda mucho tener un monitor conectado para ver que está pasando durante el arranque), así que tuve que comenzar desde cero y volver a preparar la tarjeta. Afortunadamente al segundo intento todo funcionó correctamente.

2. Actualizar el sistema operativo. Lo siguiente a hacer es actualizar nuestro sistema. Para ello deberemos tener acceso a Internet (obvio) y ejecutar el comando raspbx-upgrade.

root@raspbx:~# raspbx-upgrade

Esta es una acción que deberemos realizar regularmente para mantener nuestro sistema al día.

3. Regenerar las claves RSA. Por motivos de seguridad, regeneraremos las claves RSA que por defecto son las mismas para todas las instalaciones de RasPBX. Ello lo haremos con el comando regen-hostkeys.

root@raspbx:~# regen-hostkeys

Esto no afectará a ninguna de las contraseñas mencionadas anteriormente.

4. Cambiar la zona horaria. Ajustaremos nuestra zona horaria con el comando

root@raspbx:~#configure-timezone

Un menú de texto nos guiará en la selección primero de región y después de huso horario, en mi caso el de America/Mexico_City.

5. Establecer ajustes locales. Ahora vamos a establecer los ajustes locales, para ello usamos el comando dpkg-reconfigure locales

root@raspbx:~# dpkg-reconfigure locales

Aparecerá un menú de texto donde o bien podemos instalar todos los paquetes locales posibles (no lo recomiendo) o bien desmarcar instalarlos todos y seleccionar solo aquellos que nos interesen. En mi caso he seleccionado los que comienzan por es_ES (Español de España) y ca_CA (catalán). Una vez seleccionados los paquetes que nos interesen, nos pedirá cual es el idioma por defecto de la instalación de entre los paquetes que hemos seleccionado.

6. Establecer una nueva contraseña. Para acabar vamos a cambiar la contraseña del sistema operativo, para ello usaremos el comando passwd

root@raspbx:~# passwd

Nos pedirá la nueva contraseña por duplicado. Siempre es recomendable una contraseña segura que contenga mayúsculas, minúsculas, números y caracteres especiales. Si usáis caracteres cómo la @ o $, os recomiendo que ajustéis el idioma del teclado usando la utilidad raspi-config. Esto solo afecta a los teclados conectados directamente a la Raspberry, si os conectáis por SSH siempre va a usar la configuración de vuestro ordenador, pero hay que tenerlo en cuenta por si algún día no nos podemos conectar en remoto y hemos de hacerlo localmente.

 

Y con esto ya tenemos nuestra centralita IP lista para ser configurada. En un próximo artículo explicaré como configurar FreePBX para realizar y recibir llamadas usando softphones

terraform1

Terraform, la navaja suiza

/ , , / , , / 0 comments

Hoy en día nos encontramos con grandes retos que afrontar en el mundo Cloud, como el escalado de las aplicaciones y la definición de una arquitectura válida para el servicio que pretendemos desplegar. Para ello y para otro tipo de problemas, nos encontramos con herramientas comoTerraform, capaz de facilitarnos la codificación de una infraestructura dependiendo de nuestras necesidades, los servicios que tengamos que prestar y con una gran variedad de proveedores donde depositar nuestra infraestructura.

¿Qué soluciones ofrece Terraform?

Cuanto más grande se vuelve un servicio, más complicado se hace la administración y la operación del mismo de manera manual. También puede suceder que exista un servicio particular que sea necesario para nuestra aplicación y que tenga que apoyarse en otro servicio existente en un proveedor de cloud distinto de donde estamos desplegando la aplicación, por tanto nos hace enfrentarnos a distintas consolas de administración o CLI diferentes para el aprovisionamiento, configuración y administración del servicio.

Si además pretendemos crear y destruir entornos bajo demanda en distintos clouds para una misma aplicación, puede convertirse en una tarea tediosa y corremos el peligro de no hacerlo de una forma predictiva.

La solución a todos estos problemas pasaría por disponer de una herramienta que nos permita modelar nuestra infraestructura como código, pero que sea agnóstica al entorno cloud donde se ejecute. Encontramos soluciones como CloudFormation de AWS o Heat de Openstack, pero estas herramientas están ligadas al cloud donde se desea desplegar. Sin embargo, Terraform nos permite codificar nuestra infraestructura atendiendo a las necesidades de nuestro servicio y ofreciendo un amplio abanico de proveedores donde desembarcar nuestra infraestructura.

 

Mediante ficheros de configuración que generamos en formato Json o en la sintaxis propuesta por Terraform (muy cercana al lenguaje natural), modelamos las necesidades de nuestra aplicación. Normalmente usaremos un fichero para definir nuestra arquitectura, una serie de variables para poder parametrizar nuestro despliegue y algunas variables de salida para obtener los datos más importantes nuestra infraestructura una vez desplegada (por ejemplo la IP de un ELB de AWS o el endpoint de RDS).

Una vez codificada nuestra infraestructura podemos hacer uso del comando terraform apply y comenzará el despliegue de nuestra infraestructura.

A continuación vamos a mostrar un ejemplo muy sencillo usando como proveedor Docker generando un fichero llamado main.tf:

#Config Docker provider

provider "docker" {
host = "unix:///var/run/docker.sock"
}

resource "docker_container" "jenkins" {
image = "${docker_image.jenkins.latest}"
name = "terraform-demo"
ports = {
internal = 8080
external = 8080
internal = 5000
external = 5000
}
}

resource "docker_image" "jenkins" {
name = "jenkins:latest"
}

 

Ejecutamos el comando terraform apply y observaremos como Terraform se encarga de generar los recursos definidos en nuestro fichero hasta llegar al estado objetivo:

terraform apply
docker_image.jenkins: Refreshing state... (ID: sha256:d5c0410b1b443d3ed805078d498526590ae76fc42a1369bc814eb197f5ee102bjenkins:latest)
docker_container.jenkins: Refreshing state... (ID: 0904115a38630b0f8c7871da9eba9971c3a4ad67acb20d694ef20adc53225d5b)
docker_container.jenkins: Creating...
  bridge:                   "" => "<computed>"
  gateway:                  "" => "<computed>"
  image:                    "" => "sha256:d5c0410b1b443d3ed805078d498526590ae76fc42a1369bc814eb197f5ee102b"
  ip_address:               "" => "<computed>"
  ip_prefix_length:         "" => "<computed>"
  log_driver:               "" => "json-file"
  must_run:                 "" => "true"
  name:                     "" => "terraform-demo"
  ports.#:                  "" => "1"
  ports.376939551.external: "" => "5000"
  ports.376939551.internal: "" => "5000"
  ports.376939551.ip:       "" => ""
  ports.376939551.protocol: "" => "tcp"
  restart:                  "" => "no"
docker_container.jenkins: Creation complete

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

The state of your infrastructure has been saved to the path
below. This state is required to modify and destroy your
infrastructure, so keep it safe. To inspect the complete state
use the `terraform show` command.

State path: terraform.tfstate

Tras la ejecución del comando hemos obtenido como resultado un contenedor con una imagen de jenkins y un fichero llamado terraform.tfstate. Dicho fichero almacena el estado actual de la infraestructura y es consultado por Terraform para obtener la información antes de aplicar nuevos cambios sobre la misma. Si borramos el fichero y volvemos a aplicar el plan, obtendremos un mensaje de error indicando que no puede aplicar los cambios:

Error applying plan:

1 error(s) occurred:

* docker_container.jenkins: Unable to create container: container already exists

Terraform does not automatically rollback in the face of errors.
Instead, your Terraform state file has been partially updated with
any resources that successfully completed. Please address the error
above and apply again to incrementally change your infrastructure.

 

Es por ello que para evitar problemas a la hora de lanzar cambios contra la infraestructura que:

  • O se incluya el fichero terraform.tfstate dentro del sistema de control de versiones.
  • Que los cambios se lleven a cabo desde un único punto o máquina para evitar que dos o más personas lancen cambios desde sitios distintos y con ficheros de state distinto.

Si en cualquier caso sucede que el fichero terraform.state contiene información que no se encuentra sincronizada con lo que se encuentra en la infraestructura, siempre podrá utilizarse el comando terraform refresh para reconciliar los datos del fichero terraform.state.

Otra herramienta que ofrece terraform es mostrar un diagrama con el plan de ejecución de la infraestructura. Para ello utilizamos el comando terraform graph:

digraph {
	compound = "true"
	newrank = "true"
	subgraph "root" {
		"[root] docker_container.jenkins" [label = "docker_container.jenkins", shape = "box"]
		"[root] docker_image.jenkins" [label = "docker_image.jenkins", shape = "box"]
		"[root] provider.docker" [label = "provider.docker", shape = "diamond"]
		"[root] docker_container.jenkins" -> "[root] docker_image.jenkins"
		"[root] docker_image.jenkins" -> "[root] provider.docker"
	}
}

Haciendo uso de dot de GraphViz podemos exportar nuestro diagrama en formato png usando el siguiente comando:

terraform graph | dot -Tpng > jenkinsDocker.png

Otra interesante funcionalidad es poder definir un provisionador asociado a otro recurso. De tal forma que podemos desplegar una máquina en un cloud y lanzar comandos para que se realice la instalación de los componentes software que pudiéramos llegar a necesitar en la misma. Puede, por ejemplo, ejecutarse una serie de comandos sobre el recurso recién creado para lanzar unplaybook de ansible desplegado en otro repositorio de código para finalizar la instalación de la máquina.

Conclusión

En definitiva, Terraform es una herramienta muy interesante para poder llevar a cabo nuestros despliegues completos de un servicio sea cual sea su magnitud y complejidad. El hecho de poder tracerar los cambios de nuestra infraestructura en un sistema de control de versiones, hace que sea más sencillo observar la evolución de nuestro servicio, poder controlar los cambios que hayan hecho mejorar o empeorar el rendimiento del mismo e incluso poder trasladar una solución arquitectónica de un servicio completo para otro proyecto de similares características.

También reduce costes y tiempo derivados de la operación y mantenimiento del servicio, ya que se necesita menos esfuerzo para controlar una infraestructura compleja.

Por último, Terraform es un gran aliado para construir nuestros pipelines de integración y despliegue continuo, ya que podemos automatizar todos los procesos de generación y destrucción de entornos, tanto efímeros como persistentes, para pruebas o para llevar hasta producción los cambios realizados en nuestras infraestructuras.