El blog de Andrés

Opciones para instalar R en una Raspberry Pi y otros sistemas ARM

Sat, 11 Feb 2023 00:00:00 +0000

Esto comenzó como una sección en algunas de mis otras publicaciones, pero a medida que las opciones de instalación comenzaron a acumularse, comenzó a ocupar demasiado espacio para ser solo una sección en un artículo, por lo que decidí convertirlo en un artículo propio.

Las opciones descritas aquí se aplican principalmente a la familia de computadoras de placa única Raspberry Pi, pero dado que la mayoría de opciones también funcionan en distribuciones Ubuntu, también pueden aplicarse a otros sistemas Linux ARM como otros SBC o incluso computadoras ARM de “tamaño completo” como Ampere Altra o AWS Gravitón.

Instalar desde los repositorios del Sistema Operativo

Esta es la opción más fácil, puedes instalar R desde los repositorios estándar para tu sistema operativo, pero esas versiones de R suelen ser bastante antiguas, por ejemplo, la última versión de Raspberry Pi OS viene con R 4.2.2 y Ubuntu 22.04 viene con R 4.1.2.

Para instalar R con esta opción, solo necesitas ejecutar este comando en tu terminal de sistema:

sudo apt install r-base

Esto está bien si solo quieres probar R o hacer cosas simples con él, pero si vas a trabajar en un proyecto serio, es probable que desees comenzar con una versión actualizada de R.

Compilar R desde la fuente

Otra opción es compilar la última versión de R tu mismo (4.3.1 al momento de escribir) a partir de los archivos de código fuente, esta es una tarea que requiere mucho tiempo y puede resultar un poco intimidante para los recién llegados, pero te brinda la mayor flexibilidad cuando se trata de configurar las opciones de compilación, por ejemplo, puede elegir opciones como compilar con BLAS y LAPACK para acelerar cálculos de matriciales.

Puedes compilar R desde la fuente ejecutando este script en una terminal del sistema, funciona tanto para las distribuciones de Raspberry Pi OS como de Ubuntu:

sudo su
    
# Define la version R a instalar
R_VERSION=4.3.1

apt install -y g++ gcc gfortran libreadline-dev libx11-dev libxt-dev \
            libpng-dev libjpeg-dev libcairo2-dev xvfb \
            libbz2-dev libzstd-dev liblzma-dev libtiff5 \
            libssh-dev libgit2-dev libcurl4-openssl-dev \
            libblas-dev liblapack-dev libopenblas-base \
            zlib1g-dev openjdk-11-jdk \
            texinfo texlive texlive-fonts-extra \
            screen wget libpcre2-dev make cmake
cd /usr/local/src
wget https://cran.rstudio.com/src/base/R-${R_VERSION:0:1}/R-$R_VERSION.tar.gz
tar zxvf R-$R_VERSION.tar.gz
cd R-$R_VERSION
./configure --enable-R-shlib --enable-memory-profiling --with-blas --with-lapack #BLAS y LAPACK son opcionales
make
make install
cd ..
rm -rf R-$R_VERSION*
exit

Instalar R usando rig

rig es un administrador de instalación de R que te permite instalar varias versiones de R una al lado de la otra. Recientemente agregó soporte para sistemas Linux ARM64 a través del repositorio de GitHub rstudio/r-builds , aunque se estipula que estas compilaciones son un recurso de la comunidad, Posit no los apoya profesionalmente. Actualmente solo admite distribuciones Ubuntu y Debian (La última versión de Raspberry Pi OS se basa en Debian 12, por lo que también es compatible).

Puedes instalar rig en tu sistema ejecutando este comando en una terminal del sistema:

curl -Ls https://github.com/r-lib/rig/releases/download/latest/rig-linux-arm64-latest.tar.gz |
  sudo tar xz -C /usr/local

Luego puedes instalar la última versión estable de R con estos comandos:

sudo rig add release # O una versión especifica como 4.3.1
sudo rig default release

Opcionalmente, puedes descargar e instalar R manualmente desde R-hub como se explica en el repositorio Github rstudio/r-builds, pero este es un procedimiento más complicado que solo vale la pena si vas a integrarlo en tu propio flujo de trabajo de administración de infraestructura y deseas evitar la sobrecarga de instalar rig.

Instalar R desde el Proyecto R4Pi

Y por último, pero no menos importante, mi nuevo favorito, puedes instalar R desde el proyecto R4Pi a través de su repositorio deb, lo que significa que siempre obtendrá actualizaciones de la versión R simplemente ejecutando sudo apt update && sudo apt upgrade. Actualmente es compatible con la última versión de Raspberry Pi OS (basada en Debian 12) pero ten presente que el soporte es sólo para 64-bits. Tambien, hay planes para soportar Ubuntu 24.04 LTS arm64 en un futuro cercano.

Para agregar el repositorio deb de R4Pi a tu lista de fuentes deb e instalar R, ejecuta estos comandos en una terminal del sistema:

source /etc/os-release
curl -O  https://pkgs.r4pi.org/dl/${VERSION_CODENAME}/r4pi-repo-conf_0.0.1-1_all.deb
sudo dpkg -i  r4pi-repo-conf_0.0.1-1_all.deb
sudo apt update
sudo apt upgrade
sudo apt install r4pi
rm r4pi-repo-conf_0.0.1-1_all.deb

El principal beneficio del proyecto R4Pi es que también proporciona repositorios de paquetes R con binarios precompilados para una gran selección de paquetes R, lo que reduce en gran medida el tiempo y el esfuerzo necesarios para instalar paquetes R en Raspberry Pi y, por cierto, también puedes usar el repositorio de paquetes R4Pi con todas las opciones de instalación anteriores simplemente configurando la opción “repos” en un archivo .Rprofile.

local({r <- getOption("repos")
       r["R4Pi"] <- "https://pkgs.r4pi.org/bookworm"
       r["CRAN"] <- "https://cran.rstudio.com/" # Repositorio secundario para cuando no hay binario disponible
       options(repos=r)})

Instalación de Quarto-CLI en sistemas Linux-arm64

Fri, 09 Dec 2022 00:00:00 +0000

ACTUALIZACIÓN:

Este artículo ya no es relevante debido a la disponibilidad de compilaciones oficiales de Quarto para la arquitecura arm64. Ahora la instalación es bastante simple:

# Descarga el instalador deb
wget https://github.com/quarto-dev/quarto-cli/releases/download/v1.3.433/quarto-1.3.433-linux-arm64.deb
# Instala Quarto
sudo dpkg -i quarto-1.3.433-linux-arm64.deb

Dejaré el artículo anterior abajo como referencia.

Quarto es el nuevo sistema de publicación científica y técnica de código abierto de Posit basado en Pandoc que permite entrelazar texto narrativo y código para producir resultados de alta calidad, incluidos informes, presentaciones, sitios web y más. Es el sucesor del ecosistema R Markdown de gran éxito, pero específico de R, que lleva todos los beneficios de R Markdown a otros lenguajes de programación como Python, Julia y Observable.

Desafortunadamente, debido a la falta de fuentes oficiales de binarios arm64 para algunas de sus dependencias (por ejemplo, Deno, SASS, Pandoc), y como me explicaron, su ancho de banda limitado para soportar arquitecturas no suficientemente populares como Linux arm64. Quarto no admite oficialmente la arquitectura arm64, pero eso no significa que no podamos hacer que funcione en ella nosotros mismos.

Con la amable ayuda de Carlos Scheidegger (@scheidegger@mastodon.social), un ingeniero de software de Posit que trabaja en Quarto, Me las arreglé para instalar Quarto en sistemas arm64 y me gustaría compartir cómo lo hice con la comunidad R.

Plataforma de Prueba

Probé esto en Raspberry Pi 3B+ y 4B con Raspberry Pi OS y Ubuntu 22.04 LT, y en una máquina virtual Oracle Ampere Altra con Ubuntu 22.04 LTS, por lo que estoy bastante seguro de que debería funcionar en cualquier sistema arm64, siempre que puedas obtener versiones arm64 adecuadas de las dependencias de Quarto en tu distribución de Linux específica. En todos los casos, comencé con una instalación limpia y actualizada del sistema operativo, así que asegurate de actualizar el tuyo también antes de comenzar.

sudo apt update
sudo apt dist-upgrade

Instalación de Dependencias

Primero, necesitamos una versión arm64 suficientemente moderna de Pandoc, y dado que la versión que viene con los repositorios deb estándar para su sistema operativo probablemente sea demasiado antigua, es mejor que descarguemos una versión moderna nosotros mismos (esto es muy importante ya que Quarto fallará con versiones anteriores de Pandoc).

wget https://github.com/jgm/pandoc/releases/download/2.19.2/pandoc-2.19.2-1-arm64.deb
sudo dpkg -i pandoc-2.19.2-1-arm64.deb
rm pandoc-2.19.2-1-arm64.deb

Además, necesitamos R y el paquete R rmarkdown, pero dado que estás leyendo este artículo en un blog relacionado con R, asumiré que ya tienes R instalado en tu sistema y sabes cómo instalar paquetes R, si no lo sabes, puedes revisar esta otra publicación donde detallo opciones para instalar R en una Raspberry Pi. Para aclarar, estoy considerando R como una dependencia porque estoy escribiendo en un blog relacionado con R, pero si vas a usar Quarto con algún otro lenguaje de programación, R no es obligatorio.

Instalación de Quarto

Dado que no hay binarios arm64 para Quarto, lo instalaremos desde la fuente. Sigue estos pasos de arriba a abajo sin saltarte ninguno ya que todos dependen del anterior:

Primero, necesitamos clonar el repositorio de GitHub en una ubicación adecuada. Ten en cuenta que, opcionalmente, puedes clonar una versión de lanzamiento específica si lo prefieres utilizando la opción --branch (por ejemplo, --branch v1.3.47)

sudo su -

cd /usr/local/src

git clone --depth 1 https://github.com/quarto-dev/quarto-cli

cd quarto-cli

A continuación, vamos a engañar a Quarto para que instale una versión arm64 de Deno desde una fuente alternativa modificando su archivo configure.sh antes de ejecutarlo.

sed -i 's/https:\/\/github.com\/denoland\/deno\/releases\/download/https:\/\/github.com\/LukeChannings\/deno-arm64\/releases\/download/' configure.sh
sed -i 's/DENOFILES=deno-x86_64-unknown-linux-gnu.zip/DENOFILES=deno-linux-arm64.zip/' package/scripts/common/utils.sh
sed -i 's/DENO_DIR=deno-x86_64-unknown-linux-gnu/DENO_DIR=deno-linux-arm64/' package/scripts/common/utils.sh

./configure.sh

Finalmente, vamos a reemplazar los binarios externos amd64 que Quarto descarga durante la instalación con binarios arm64.

mkdir package/dist/bin/tools/deno-x86_64-unknown-linux-gnu/
ln -s /usr/local/src/quarto-cli/package/dist/bin/tools/deno-linux-arm64/deno package/dist/bin/tools/deno-x86_64-unknown-linux-gnu/deno

rm package/dist/bin/tools/pandoc
ln -s /usr/bin/pandoc package/dist/bin/tools/pandoc

rm -rf package/dist/bin/tools/dart-sass/
wget https://github.com/sass/dart-sass/releases/download/1.57.1/dart-sass-1.57.1-linux-arm64.tar.gz
tar zxvf dart-sass-1.57.1-linux-arm64.tar.gz
rm dart-sass-1.57.1-linux-arm64.tar.gz
mv -f dart-sass/ package/dist/bin/tools/

Si todo salió bien, ahora tienes una instalación funcional de la interfaz de línea de comandos de Quarto en tu sistema, y puedes comenzar a renderizar archivos qmd desde la terminal. Para probar si realmente funciona, rendericemos un documento de prueba; crea un archivo test.qmd con el siguiente contenido:

---
title: "Test Document"
format: html
---

## Hello

```{r}
print("world")
```

Y renderiza el documento desde una terminal del sistema con el siguiente comando:

quarto render test.qmd

Si todo va bien, obtendrás un archivo test.html en la ubicación actual.

No he descubierto cómo habilitar la integración de RStudio IDE con Quarto (las compilaciones experimentales de RStudio para arm64 vienen con las funciones de integración con Quarto deshabilitadas). He planteado la pregunta en el repositorio de GitHub y actualizaré esta publicación si surge una solución.

Instalando tu propio Servidor Shiny y RStudio en una Raspberry Pi

Mon, 05 Sep 2022 00:00:00 +0000

Este artículo se publicó originalmente en 2018 y muchas cosas han cambiado desde entonces, por lo que lo reescribí por completo para tener en cuenta los avances más recientes en la compatibilidad con la arquitectura arm64 dentro del ecosistema R.

En 2018, participé en un tema de foro en Posit Community donde @jladata preguntaba si una Raspberry Pi 3B+ podría convertirse en un servidor Shiny viable. De hecho, yo uso una Raspberry Pi para ese mismo propósito, así que decidí compartir con la comunidad R mi experiencia al configurar Shiny y Rstudio Server de forma nativa en una Raspberry Pi.

En esos días había casi cero soporte para arquitecturas ARM (ya sea x32 o x64), por lo que la mayor parte del software tenía que compilarse desde la fuente en la misma Pi, lo que hace que el proceso de instalación sea un esfuerzo titánico con muchisimas horas de espera.

Hoy en día, las cosas han cambiado y tenemos un mejor soporte para la arquitectura arm64 debido a los esfuerzos de la comunidad e incluso soporte oficial de RStudio en proceso. En este renovado artículo, te guiaré a través de las opciones de instalación que tenemos disponibles actualmente.

✏️ También tengo un artículo relacionado que muestra cómo automatizar el proceso de instalación usando Ansible.

Preparando la Raspberry Pi

Primero, necesitas un sistema operativo de 64 bits para tu Pi (asegúrate de que sea de 64 bits ya que RStudio solo es compatible con la arquitectura arm64), estas instrucciones de instalación funcionan tanto para Raspberry Pi OS como para Ubuntu, puedes descargar cualquiera de los dos usando el software Raspberry Pi Imager (sitio oficial). También, asegúrate de actualizar las bibliotecas de tu sistema con sudo apt update && sudo apt dist-upgrade antes de comenzar.

Aunque no es obligatorio, recomiendo realizar las siguientes acciones utilizando la aplicación sudo raspi-config (en Ubuntu, primero debes instalarla con sudo apt install raspi-config):

Expandir el sistema de archivos (Advanced Options / Expand Filesystem).
Definir tu configuración regional, asegúrate de elegir una opción UTF.8 para evitar problemas de compilación (Localisation Options / Locale).
Deshabilitar “Interfaces de red predecibles” (Advanced Options / Network Interface Names).

A continuación, debes configurar una IP estática para que puedas encontrar la Pi fácilmente en tu red.

Para configurar una IP estática en Raspberry Pi OS, ejecuta estos comandos. Esta es una configuración de IP de muestra para una conexión por cable, modificala de acuerdo a tus propias necesidades:

# Configuración IP de muestra:
sudo nmcli c mod 'Wired connection 1' ipv4.addresses 192.168.1.101/24 ipv4.method manual
sudo nmcli con mod 'Wired connection 1' ipv4.gateway 192.168.1.1
sudo nmcli con mod 'Wired connection 1' ipv4.dns "192.168.1.1"
sudo nmcli c down 'Wired connection 1' && sudo nmcli c up 'Wired connection 1'

Y para configurar la IP en Ubuntu, debes crear este archivo, sudo nano /etc/netplan/01-netcfg.yaml, agregar este contenido (edítalo según sea necesario) y aplicar la configuración con este comando, sudo netplan apply.

network:
    version: 2
    renderer: networkd
    ethernets:
        eth0:
            dhcp4: false
            addresses:
                - 192.168.1.101/24
            nameservers:
                addresses: [8.8.8.8, 8.8.4.4, 192.168.1.1]
            routes:
                - to: default
                  via: 192.168.1.1

En caso de que tengas un modelo de Raspberry Pi con poca RAM, debes agregar algo de memoria sawp para el proceso de instalación. Para los modelos Pi de 1 GB, 3 GB de sawp serían suficientes, puedes hacerlo con estos comandos:

sudo /bin/dd if=/dev/zero of=/var/swap.1 bs=1M count=3072
sudo chmod 600 /var/swap.1
sudo /sbin/mkswap /var/swap.1
sudo /sbin/swapon /var/swap.1
sudo sh -c 'echo "/var/swap.1 swap swap defaults 0 0 " >> /etc/fstab'

Para evitar el uso innecesario de la memoria swap y proteger tu tarjeta SD, abre este archivo, sudo nano /etc/sysctl.conf, y agrega esta línea al final:

    vm.swappiness=10

Instalar R

Tienes varias opciones para instalar R en tu Pi:

Instalar desde los repositorios del Sistema Operativo (No recomendado)
Compilar R desde la fuente
Instalar R usando rig
Instalar R desde el Proyecto R4Pi

Como ahora hay varias opciones, he movido esta sección a un artículo aparte que puedes consultar aquí para obtener más detalles.

Siempre que sea posible (con un sistema operativo compatible), recomiendo usar el repositorio de paquetes de R4Pi como tu fuente de paquetes R, ya que proporciona archivos binarios precompilados que hacen que la instalación sea más fácil y rápida.

Instalar Shiny Server

Actualmente, shiny-server no ofrece compatibilidad con ARM, por lo que la única opción para instalarlo en una Pi es compilar desde la fuente. Hay esperanza de que esto cambie en el futuro según la respuesta a este GitHub Issue, pero por el momento estamos atrapado con esto.

Primero, debes instalar las dependencias de paquetes R, si estás utilizando un repositorio CRAN, esto llevará un tiempo, pero es mucho más rápido si estás utilizando el repositorio R4Pi (disponible con R instalado desde R4Pi):

# Define tu repositorio de paquetes R (Debes escoger uno de estos)
# REPO="'http://cran.rstudio.com/'" # Para sistemas operativos no compatibles con los binarios compilados para RPi OS (basada en Debian 12)
# REPO="c('https://pkgs.r4pi.org/noble', 'http://cran.rstudio.com/')" # Para Ubuntu 24.04
REPO="c('https://pkgs.r4pi.org/bookworm', 'http://cran.rstudio.com/')" # Para la versión de RPi OS más reciente (basada en Debian 12)

# Asegúrate de que las dependencias del sistema estén instaladas
sudo apt install libcairo2-dev libxt-dev git cmake pandoc

# Instala los paquetes R requeridos como sudo
sudo su - -c "R -e \"install.packages('Rcpp', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('later', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('fs', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('R6', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('Cairo', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('httpuv', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('mime', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('jsonlite', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('digest', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('htmltools', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('xtable', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('sourcetools', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('shiny', repos=$REPO)\""
sudo su - -c "R -e \"install.packages('rmarkdown', repos=$REPO)\""

✏️ Es necesario instalar los paquetes de R como sudo para que shiny-server pueda usarlos, no instales estos paquetes desde la consola de R usando tu usuario habitual.

Ahora, puedes instalar shiny-server con estos comandos:

# Descarga el código fuente de la última versión shiny-server desde GitHub
git clone --depth 1 --branch v1.5.23.1030 https://github.com/rstudio/shiny-server.git

# Compila el código fuente
cd shiny-server
DIR=`pwd`
PATH=$DIR/bin:$PATH
mkdir tmp
cd tmp
PYTHON=`which python`
sudo cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DPYTHON="$PYTHON" ../
sudo make
mkdir ../build

# Instala node
(cd .. && sudo ./external/node/install-node.sh)
(cd .. && ./bin/npm ci --omit-dev --python="${PYTHON}") 

# Instala shiny-server
sudo make install

# Configura shiny-server
sudo mkdir -p /etc/shiny-server
sudo cp ../config/default.config /etc/shiny-server/shiny-server.conf
cd
sudo rm -rf shiny-server
sudo ln -s /usr/local/shiny-server/bin/shiny-server /usr/bin/shiny-server
sudo useradd -r -m shiny
sudo mkdir -p /var/log/shiny-server
sudo mkdir -p /srv/shiny-server
sudo mkdir -p /var/lib/shiny-server
sudo chown shiny /var/log/shiny-server

# Edita el archivo shiny-server.service
sudo nano /etc/systemd/system/shiny-server.service 
    # Pega el siguiente contenido
    
    [Unit]
    Description=ShinyServer

    [Service]
    Type=simple
    ExecStart=/usr/bin/env bash -c 'exec /usr/local/shiny-server/bin/shiny-server >>     /var/log/shiny-server.log 2>&1'
    KillMode=process
    ExecReload=/usr/bin/env kill -HUP $MAINPID
    ExecStopPost=/usr/bin/env sleep 5
    Restart=on-failure
    RestartSec=1
    StartLimitInterval=45
    StartLimitBurst=3

    [Install]
    WantedBy=multi-user.target

# Edita el archivo shiny-server para logrotate
sudo nano /etc/logrotate.d/shiny-server 
    # Pega el siguiente contenido
    
    /var/log/shiny-server.log {
       rotate 12
       copytruncate
       compress
       missingok
       size 1M
    }

# Establece los permisos para los archivos
sudo chown root:root /etc/systemd/system/shiny-server.service
sudo chmod 644 /etc/systemd/system/shiny-server.service
sudo chown root:root /etc/logrotate.d/shiny-server
sudo chmod 644 /etc/logrotate.d/shiny-server

# Inicia el servicio
sudo systemctl daemon-reload
sudo systemctl enable shiny-server
sudo systemctl start shiny-server

# Crea los enlaces simbolicos para pandoc y las aplicaciones de muestra
sudo ln -s -f /usr/bin/pandoc /usr/local/shiny-server/ext/pandoc/pandoc
sudo ln -s -f /usr/bin/pandoc-citeproc-preamble /usr/local/shiny-server/ext/pandoc/pandoc-citeproc
sudo ln -s /usr/local/shiny-server/samples/sample-apps /srv/shiny-server/sample-apps
sudo ln -s /usr/local/shiny-server/samples/welcome.html /srv/shiny-server/index.html

# Establece los permisos de usuario adecuados, estoy asumiendo que tu usuario es "pi", cámbialo si no lo es
sudo groupadd shiny-apps
sudo usermod -aG shiny-apps pi
sudo usermod -aG shiny-apps shiny
cd /srv/shiny-server
sudo chown -R pi:shiny-apps .
sudo chmod g+w .
sudo chmod g+s .
cd

Instala RStudio Server

En el pasado, la única forma de instalar RStudio Server en una Pi era compilar desde la fuente y esto requería mucho tiempo (me tomó 3 días la última vez que probé en una Pi 3B+) y era muy propenso a fallar porque RStudio IDE estaba en desarrollo activo.

Afortunadamente, desde entonces, RStudio ha puesto a disposición compilaciones “experimentales” del IDE para arm64 (escribí un artículo al respecto), están compiladas para Ubuntu 22, 24 LTS, RedHat 9 y 10. Los binarios para Ubuntu 22 y 24 también son compatibles con Raspberry Pi OS. Puedes consultar las compilaciones diarias disponibles aquí. Elije un enlace de acuerdo con el sistema operativo que estás utilizando, también ten en cuenta que estas compilaciones están destinadas a pruebas, por lo que es probable que tengan errores o sean inestables, si tienes problemas para instalar la última versión disponible, intenta con una versión anterior .

Las siguientes instrucciones usan un enlace para Ubuntu 24 (compatible con Raspberry Pi OS), recuerda cambiar el enlace si deseas usar otro sistema operativo o una versión más reciente del IDE:

sudo apt install gdebi
wget https://s3.amazonaws.com/rstudio-ide-build/server/jammy/arm64/rstudio-server-2026.01.0-392-arm64.deb
sudo gdebi rstudio-server-2026.01.0-392-arm64.deb
sudo rm rstudio-server-2026.01.0-392-arm64.deb

✏️ Actualizaré esta sección una vez que el soporte arm64 se convierta en una función estable del RStudio IDE.

Instalar Servicios de Soporte Adicionales (opcional)

Nginx es un servidor web de bajos requisitos, que resulta útil para autohospedar archivos HTML, pero también para usarlo como proxy inverso (más información sobre esto en la siguiente sección). Puedes instalarlo con este comando:

sudo apt install nginx

También, para trabajar con conjuntos de datos “más grandes que la memoria” (ten en cuenta que la Pi no tiene mucha RAM), tener un RDBMS es útil. Personalmente prefiero PostgreSQL ya que es de código abierto y tiene capacidades impresionantes, puedes instalar PostgreSQL con este comando:

sudo apt install postgresql libpq-dev postgresql-client postgresql-client-common

Pasos Adicionales (opcional)

Crea direcciones URL agradables para Shiny y Rstudio Server (por ejemplo, http://your-ip/shiny/your-app en lugar de http://your-ip:3838/your-app) utilizando Nginx como proxy inverso, solo necesitas reemplazar el contenido de este archivo, sudo nano /etc/nginx/sites-enabled/default, con esto:

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    
    root /var/www/html;
    
    index index.html index.htm;
    
    server_name _;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    rewrite ^/shiny$ $scheme://$http_host/shiny/ permanent;
    
    location /shiny/ {
        rewrite ^/shiny/(.*)$ /$1 break;
        proxy_set_header    Host $host;
        proxy_set_header    X-Real-IP $remote_addr;
        proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header    X-Forwarded-Proto $scheme;
        proxy_pass          http://localhost:3838;
        proxy_read_timeout  20d;
        proxy_buffering off;
        
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_http_version 1.1;
        
        proxy_redirect      / $scheme://$host/shiny/;
    }
    
    location /rstudio/ {
        rewrite ^/rstudio/(.*)$ /$1 break;
    
        proxy_pass http://localhost:8787;
    
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_read_timeout 20d;
        proxy_buffering off;
    
        proxy_set_header X-RStudio-Root-Path /rstudio;
    
        proxy_set_header Host $host:$server_port;
    }
}

En Raspberry Pi OS, hay un problema extraño en el que Nginx se inicia antes de que RStudio Server pueda iniciarse y el proxy inverso falla. Una solución para esto es editar este archivo, sudo nano /etc/systemd/system/multi-user.target.wants/nginx.service, y reemplazar la parte que dice After=network.target con After=network-online.target y recargar el daemon con sudo systemctl daemon-reload. Puedes omitir esto si estás usando Ubuntu.

Ahora tienes que reiniciar Nginx para aplicar los cambios:

sudo systemctl restart nginx

Si deseas tener acceso a tu servidor desde orígenes remotos (a través de Internet), debes seguir estos pasos adicionales:

Si no tienes una IP pública estática:
- Abre una cuenta en un servicio de DNS dinámico (por ejemplo, https://www.noip.com)
- Configura Dynamic DNS en tu enrutador/módem, si no tiene esa opción, puedes instalar un cliente DDNS en tu servidor.
- Opcionalmente, configura tu nombre de dominio personal para que apunte a tu servicio DDNS.
Si tienes un IPv4 publico, configura el reenvío de puertos en tu enrutador/módem:
- Para SSH, SCP y SFPT, abre el puerto TCP/UDP 22
- Si no has configurado Nginx, abre el puerto 8787 para RStudio Server.
- Si no has configurado Nginx, abre el puerto 3838 para Shiny Server.
- Para HTTP abre el puerto TCP 80 (también para usar Nginx como proxy inverso).
- Para PostgreSQL abre el puerto TCP/UDP 5432
- Asegúrate de tener “Block WAN Traffic” deshabilitado en tu enrutador/módem.

Si estás interesado, tengo un artículo que brinda un ejemplo de cómo configurar el reenvío de puertos en casa.

Comentarios finales

El soporte para arm64 en general está aumentando rápidamente, por lo que es muy probable que las cosas cambien en un futuro próximo. Voy a hacer todo lo posible para mantener este artículo actualizado con los últimos desarrollos para que puedan aprovechar los beneficios.

El rendimiento es relativamente pobre, especialmente para gráficos, pero es utilizable. Ten en cuenta que aunque la Raspberry Pi tiene 4 núcleos, no son rápidos y la mayoría de los paquetes R no usan computación paralela.

Prueba el soporte experimental del IDE de RStudio para arquitecturas arm64

Mon, 22 Aug 2022 00:00:00 +0000

La apuesta de Apple por la arquitectura arm con sus procesadores M1 y M2 ha tenido un efecto secundario interesante, los desarrolladores de software convencional ahora se ven obligados a soportar la arquitectura arm64 y, dado que ya soportan macOS para los procesadores Apple Silicon de todos modos, soportar distribuciones Linux arm64 ya no es una carga para ellos. El equipo de desarrollo del RStudio IDE no es ajeno a esta circunstancia y han estado trabajando en el soporte general de arm64, actualmente, han puesto a disposición compilaciones experimentales para la arquitectura arm64 (también conocida como aarch64) compiladas para Ubuntu 20/22 LTS (siendo la compilación para Ubuntu 22 compatible con la última versión de Raspberry Pi OS x64 basada en Bookworm) y RedHat 9. He decidido probarlas en mi Raspberry Pi SBC, si estás interesado, únete a mí en el proceso de instalación.

Configuración básica y dependencias

Lo primero que necesitas es una Raspberry Pi (3/3/5) con Raspberry Pi x64 OS (Basado en Debian 12) o Ubuntu 20/22 LTS x64 instalado y actualizado (o cualquier otro sistema Linux arm64 ejecutando un sistema operativo soportado), asegúrate de actualizar las bibliotecas de tu sistema antes de comenzar.

sudo apt update
sudo apt dist-upgrade

Luego, la dependencia más importante para RStudio es, como era de esperarse, el lenguaje R. Tienes algunas opciones para instalar R en sistemas arm, cada una con sus pros y sus contras:

Instalar desde los repositorios del Sistema Operativo
Compilar R desde la fuente
Instalar R usando rig
Instalar R desde el Proyecto R4Pi

Como ahora hay varias opciones, he movido esta sección a un artículo aparte que puedes consultar aquí para obtener más detalles.

En todos los casos, recomiendo usar el repositorio de paquetes de R4Pi como tu fuente de paquetes R, ya que proporciona archivos binarios precompilados que hacen que la instalación sea más fácil y rápida.

Las últimas compilaciones experimentales del IDE RStudio (compilaciones >= 2023.08.0) para arm64 ahora vienen con Quarto y Pandoc incluidos, por lo que ya no es necesario instalarlos por separado y las características de integración con Quarto ahora son totalmente compatibles con los sistemas arm64, aunque, si deseas un versión más reciente de cualquiera de estos programas, puedes descargar el archivo .deb correspondiente e instalarlo usando el comando dpkg.

Puedes descargar el último instalador de Pandoc desde aquí: https://github.com/jgm/pandoc/releases/
Y el último instalador de Quarto desde aquí: https://github.com/quarto-dev/quarto-cli/releases

Y el comando de instalación sería algo como esto:

sudo dpkg -i <<nombre_del_archivo.deb>>

Por último, para instalar el archivo deb del IDE de RStudio, como lo harías en un sistema x86_64, es posible que desees instalar gdebi para que maneje las dependencias de paquetes por ti:

sudo apt install gdebi

Instalación del IDE de RStudio

Ahora llegamos al grano. No existe una versión estable del IDE de RStudio para arm64, pero hay compilaciones diarias experimentales disponibles aquí, tanto para las versiones de servidor como de escritorio y compiladas para Ubuntu 20/22 LTS y RedHat9. Voy a probar la versión de servidor para Ubuntu 22 porque es compatible con Raspberry Pi OS x64 y prefiero trabajar con el IDE en mi computadora normal en lugar de directamente en la Raspberry Pi, pero puedes instalar la versión de escritorio de la misma manera si lo prefieres, simplemente cambia el enlace en consecuencia.

wget https://s3.amazonaws.com/rstudio-ide-build/server/jammy/arm64/rstudio-server-2023.12.0-daily-232-arm64.deb
sudo gdebi rstudio-server-2023.12.0-daily-232-arm64.deb

Una vez completado el proceso de instalación, obtienes una instalación de RStudio IDE funcional en tu Raspberry Pi, si has elegido instalar la versión de servidor como lo hice yo, puedes abrir una sesión de RStudio abriendo un navegador en cualquier dispositivo en tu red y escribiendo la dirección correcta, es decir, http:\\direccion_ip_de_tu_pi:8787

Comentarios finales

Ten en cuenta que estas son compilaciones experimentales de la versión de desarrollo del IDE de RStudio y es probable que sean inestables y con errores, por lo que no debes confiar en esto para ningún tipo de trabajo crítico. Puedes seguir el progreso en este GitHub issue.

El rendimiento en Raspberry Pi es aceptable, dentro de lo razonable para sistemas con poca potencia como estos, pero está bastante lejos del rendimiento que obtendrías en sistemas más potentes como Apple Silicon o computadoras arm64 de tamaño completo si tienes acceso a una de esas (probado en una máquina virtual Ampere y funciona muy bien). Si deseas obtener el máximo rendimiento de tu Pi, usa Raspberry Pi OS Lite, ya que es la opción más liviana.

Espero que hayas encontrado útil este artículo, actualizaré el contenido a medida que se desarrollen las cosas.

Cómo hacer que tu servidor Shiny o Rstudio casero sea accesible desde la Internet pública

Mon, 16 Aug 2021 00:00:00 +0000

⚠️ ¡Requiere ensamblaje! Este proyecto requerie que investigues los detalles de tu equipo de red por tu cuenta.

Has instalado Shiny y/o RStudio sever en la computadora de tu casa y funciona muy bien siempre que estés conectado a tu red local, sin embargo, no puedes acceder a ellos desde otras ubicaciones, ¿qué puedes hacer?

La solución es exponer tu servidor a la Internet pública reenviando el tráfico entrante al puerto correspondiente en tu servidor. Ahora, no voy a mentirte diciéndo que este artículo te va a dar instrucciones detalladas sobre cómo hacerlo con tu router específico porque sería virtualmente imposible, cada marca de router (incluso modelo) tiene una interfaz de administración diferente, solo puedo darte los pasos requeridos junto con un ejemplo usando el router que tengo en casa, aunque, en general, el procedimiento implica los mismos pasos independientemente del modelo de router específico que tengas, así que con un poco de esfuerzo de tu parte, deberías poder averiguar cómo hacer que funcione con tu propio router.

Prerrequisitos

Estoy escribiendo este artículo asumiendo que tienes Shiny y/o RStudio server correctamente instalados en una computadora en casa.
Debes tener una IP pública asignada a tu router (no importa si cambia dinámicamente), no todos tienen una, ya que algunos proveedores de servicios de Internet (PSI) usan una configuración NAT3, lo que básicamente significa que compartes una IP pública con un grupo de sus clientes y no hay forma de canalizar una solicitud HTTP hacia tu servidor doméstico, sin embargo, es posible que puedas cambiar tu configuración NAT si llamas a tu PSI y solicitas una IP pública, por lo que puede que quieras intentarlo.
Necesitas conocer el usuario y la contraseña para acceder a la interfaz de configuración de tu router, algunos PSI lo dejan con los valores de fabrica y solo necesitas buscar en Google la contraseña predeterminada para tu modelo de router, pero en la mayoría de los casos, la cambian, por lo que tendrías que darles una llamada y preguntar por tus credenciales.

Abrir los Puertos Necesarios en el Servidor

Los puertos específicos para Shiny y/o RStudio Server deben estar accesibles en tu servidor para poder conectarse a esos servicios. La mayoría de las distribuciones de Linux vienen con todos los puertos accesibles de forma predeterminada, pero es una práctica común (y buena) instalar un firewall para restringir el acceso a tu servidor; si este es tu caso, debes asegurarte de tener abiertos los puertos necesarios.

Para Shiny server, el puerto predeterminado es 3838 y para RStudio server es 8787 (esto se puede personalizar). Si has configurado un proxy inverso con Nginx oApache, puedes obviar esos puertos y solo abrir el puerto 80 para HTTP o el puerto 443 para HTTPS. Por ejemplo, el comando para permitir el tráfico entrante en el puerto 80 usando el firewall ufw en sistemas basados en Ubuntu sería así:

sudo ufw allow 80/tcp

Y usando firewalld en sistemas basados en RHEL sería:

sudo firewall-cmd --permanent --zone=public --add-port=80/tcp
sudo firewall-cmd --reload

Puede que tengas otras reglas que podrían evitar que el tráfico ingrese a tu servidor desde ubicaciones remotas, por lo que es posible que desees inspeccionar las reglas de tu firewall y buscar cualquier cosa que restrinja el tráfico entrante.

Configura el Reenvio de Puertos en tu Router

Abre un navegador web en un dispositivo que esté conectado a tu red local y escribe la IP local de tu router, por lo general, es algo como 192.168.0.1 o 192.168.1.1. Todos los routers tienen un servidor web que se ejecuta en el puerto 80 de forma predeterminada, por lo que al escribir su IP se abrirá una página web con la interfaz de configuración.

En mi caso particular, sigo usando el módem Sagemcom HFC que me dio mi PSI (porque siempre voy a configurar un router pfSense personalizado muy pronto), así que si abro un navegador Chrome y escribo 192.168 .0.1 esto es lo que obtengo.

En tu caso, la interfaz de usuario se verá diferente y las opciones podrían tener nombres ligeramente distintos, pero son básicamente las mismas.

Ingresa tus credenciales para acceder a la interfaz de configuración, que en mi caso se ve así.

Luego, busca entre todas las pestañas disponibles para encontrar la sección “reenvío de puertos” (Port Forwarding en inglés), no estará en el mismo lugar para ti, pero la mayoría de routers modernos tienen esta opción.

Una vez allí, agrega las reglas de reenvío para Shiny y/o Rstudio server (debes reemplazar “IP_del_servidor” con la IP local de tu servidor) y aplica los cambios.

Dirección Local	Puerto Inicial	Puerto Final	Dirección Externa	Protocolo	Descripción
IP_del_servidor	3838	3838	0.0.0.0	TCP	Shiny-Server
IP_del_servidor	8787	8787	0.0.0.0	TCP	RStudio-Server

Si está utilizando un proxy inverso, solo necesitas asegurarte de tener una de estas.

Dirección Local	Puerto Inicial	Puerto Final	Dirección Externa	Protocolo	Descripción
IP_del_servidor	80	80	0.0.0.0	TCP	HTTP
IP_del_servidor	443	443	0.0.0.0	TCP	HTTPS

Además, asegúrate de no tener la opción “Bloquear tráfico WAN” habilitada en tu router, eso bloquearía todo el tráfico entrante en absoluto.

Después de hacer todo esto, deberías poder acceder a tus aplicaciones Shiny escribiendo tu.ip.publica:3838/nombre_de_tu_app y/o a tu servidor Rstudio escribiendo tu.ip.publica:8787 en cualquier navegador.

Pasos Adicionales Opcionales

Configura un Servicio de DNS Dinámico (DDNS)

La mayoría de los servicios de Internet residencial no incluyen una IP pública “estática”, lo que significa que incluso si tienes una IP pública asignada en cada momento dado, no siempre será la misma. Se necesita una IP pública para acceder a tu servidor desde Internet directamente o para apuntar tu dominio personalizado (dirección web) a él, por lo que puedes imaginar lo inconveniente que sería tener que averiguar cuál es el IP en cada momento dado.

Para solucionar este problema, puedes utilizar un servicio de DNS dinámico (a mí me gusta utilizar No-IP). Lo que hace este servicio es actualizar automáticamente tu dominio (incluso pueden darte un subdominio gratis si lo deseas) para apuntar hacia tu IP pública actual cada vez que cambia, lo hace usando un agente DDNS incorporado en tu router si es que está disponible, o si no, usando un servicio instalado en tu servidor que reporta automáticamente la IP actual al servicio DDNS.

Si tu router tiene un agente DDNS integrado compatible, solo tienes que ingresar tus credenciales y estarás listo para comenzar.

Si tu router no tiene un angete DDNS, tendrás que instalar uno en tu servidor (proporcionado por el proveedor de DDNS). Cómo instalarlo depende del proveedor de DDNS que estés utilizando y del sistema operativo que esté ejecutando tu servidor, pero seguramente puedes encontrar instrucciones detalladas en la página de documentación de tu proveedor de DDNS.

Con este paso adicional, accederás a tus aplicaciones Shiny con: tu_dominio:3838/nombre_de_tu_app y a tu servidor RStudio con: tu_dominio:8787, lo que no requiere que conozcas tu IP pública actual por adelantado.

Configura un Proxy Inverso

Hasta el paso anterior, habíamos resuelto el problema con el cambio de dirección IP, pero todavía tenemos números de puerto extraños en las direcciones web de nuestro servidor, al configurar un proxy inverso podemos usar direcciones más agradables como: tu_dominio/shiny/nombre_de_tu_app y tu_dominio/rstudio.

Para configurar un proxy inverso, instala Nginx

sudo apt install nginx

Edita el archivo de configuración de Nginx: sudo nano /etc/nginx/sites-enabled/default, agreguando las siguientes líneas antes de la línea que dice server {

map $http_upgrade $connection_upgrade {
      default upgrade;
      ''      close;
    }

y las siguientes líneas justo después de la línea que dice server_name _;

    rewrite ^/shiny$ $scheme://$http_host/shiny/ permanent;
    # This part is for Shiny server
    location /shiny/ {
        rewrite ^/shiny/(.*)$ /$1 break;
        proxy_pass http://localhost:3838;
        proxy_redirect / $scheme://$http_host/shiny/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_read_timeout 20d;
        proxy_buffering off;
    }
    # This part is for RStudio server
    location /rstudio {
       # Needed only for prefix of /rstudio
       rewrite ^/rstudio/(.*)$ /$1 break;

       # Use http here when ssl-enabled=0 is set in rserver.conf
       proxy_pass http://localhost:8787;
       proxy_http_version 1.1;

       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection $connection_upgrade;

       # Optionally, use an explicit hostname and omit the port if using 80/443
       proxy_set_header Host $host:$server_port;

       # Not needed if there's no prefix or www-root-path is set in rserver.conf
       proxy_set_header X-RStudio-Root-Path /rstudio;

       proxy_read_timeout 20d;
    }

Ahora solo tienes que reiniciar Nginx para aplicar los cambios y listo.

sudo service nginx restart

Instalación automática de Shiny y RStudio server en Amazon Web Services con Ansible

Sun, 28 Mar 2021 00:00:00 +0000

Despues de escribir una publicación muy similar sobre la instalación de Shiny y RStudio server en una Raspberry Pi usando automatización con Ansible, me di cuenta de que el mismo enfoque se puede portar fácilmente para trabajar con servicios de computación en la nube, así que, básicamente, esta será la versión Amazon Web Services (AWS a partir de ahora) de esa publicación.

✏️ Ten en cuenta que este es un proyecto orientado a principiantes, no está destinado a ser una herramienta de producción, por lo que si ya estás familiarizado con Ansible, es posible que quieras simplemente descargar algunos roles de Ansible Galaxy e integrarlos en tu flujo de trabajo en lugar de seguir este artículo.

En caso de que no hayas leído la publicación antes mencionada, te voy a contar de qué se trata. El proceso de instalación y configuración de un servidor de ciencia de datos basado en R en AWS se puede automatizar usando una herramienta llamada Ansible, aquellos en DevOps deben estar familiarizados con el poder de Ansible, pero incluso si nunca has oído hablar de ello, no te preocupe, no necesitas saber Ansible para aprovechar sus capacidades de automatización, yo mismo no soy un experto en Ansible y he sido capaz de realizar este proyecto con solo conocimientos básicos de la herramienta, así que si yo puedo hacerlo, tu también. Te guiaré a través del proceso asumiendo que no tienes experiencia previa con esta herramienta y solo algunas habilidades básicas de terminal de Linux.

Escribí algunos playbooks de Ansible para automatizar la mayor parte del proceso de instalación, pero dejé algo de espacio para que configures la instalación a tu gusto sin tener que modificar los playbooks (lo que requeriría que sepas cómo editarlos) a través de un archivo de configuración. Aunque, si deseas tener una comprensión básica de cómo funciona esta herramienta, hay una buena serie de Ansible para principiantes en el canal de YouTube de Jeff Geerling.

En caso de que no estés familiarizado con AWS, es un proveedor de servicios en la nube que, entre muchas otras cosas, brinda acceso a servidores virtuales alojados en la nube, por lo que no tienes que encargarte tu mismo de una infraestructura física, también, para seguir con este artículo, hay algunos términos específicos de AWS que debemos definir en términos simples:

Instancia EC2: Se refiere a una instancia individual de un servidor virtual.
Amazon Machine Images (AMI): Proporciona la información necesaria para lanzar una instancia, como el sistema operativo, las bibliotecas preinstaladas y las configuraciones necesarias para que funcione un servidor. Tenga en cuenta que puede crear sus propias AMI.
Regiones: Amazon EC2 está alojado en varias ubicaciones en todo el mundo. Estas ubicaciones se componen de Regiones y cada región es un área geográfica separada.
Grupo de Seguridad: Un grupo de seguridad actúa como un firewall virtual para que su instancia controle el tráfico entrante y saliente.

Crea una Cuenta de AWS y Credenciales de Seguridad

Para utilizar los servicios de AWS, debes tener una cuenta, si ya tienes una, puedes omitir esta parte; de lo contrario, para crear una, ve a https://aws.amazon.com/es/ y haz clic en “Crear una cuenta de AWS”, completa la información requerida y sigue presionando “Continuar”, se te pedirá que proporciones la información de tu tarjeta de crédito, pero no se te cobrará por usar los productos incluidos en el “Nivel gratuito” al menos por un año.

Una vez creada tu cuenta, ve a la “Consola de administración de AWS” e inicia sesión, una vez allí, haz clic en el botón de búsqueda, escribe “EC2” y selecciona “EC2 Servidores virtuales en la nube”.

En la esquina superior derecha, elije una región adecuada, cuanto más cerca geográficamente de ti, mejor. Recuerda tu elección, ya que debes establecer esta misma ubicación en los playbooks más adelante.

Luego, en el menú de la izquierda, busca “Red y seguridad -> Pares de claves” y haz clic ahí.

En la esquina superior derecha, busca “Crear par de claves” y haz clic ahí.

Verás este cuadro de diálogo, llénalo de esta manera, haz clic en “Crear par de claves” y guarda el archivo resultante en esta ruta, ~/.ssh/aws_server.pem, en tu máquina.

Establece los permisos adecuados para tu archivo de claves, los permisos del directorio .ssh deben ser 700 (rwx______) y la clave privada (aws_server.pem) debe ser 600 (rw_______).

sudo chmod 700 ~/.ssh/
sudo chmod 600 ~/.ssh/aws_server.pem

A continuación, debes crear una clave de acceso, para que puedas tener acceso a tu cuenta mediante programación, ve al menú de tu cuenta y selecciona “Mis credenciales de seguridad”.

Luego selecciona “Crear una clave de acceso” y guarda el archivo con tus credenciales

⚠️ Manten el archivo descargado seguro y a mano, lo necesitarás más adelante. Ten cuidado de no compartir este archivo, ya que podría permitir que otras personas generen cargos en tu tarjeta de crédito.

Instala Ansible

Es posible instalar Ansible localmente en la propia instancia EC2 y ejecutar playbooks directamente en ella con connection: local pero no sería práctico porque, entre otras cosas, requeriría que lancemos manualmente la instancia EC2, es mejor ejecutar los playbooks desde un sistema que no sea tu instancia EC2.

Para instalar Ansible, si tienes un sistema basado en Unix (es decir, Linux, macOS) a tu disposición, tienes suerte, instalar Ansible es muy simple.

# Instala python3
sudo apt install python3 # En macOS usa `brew install python3`
# Instala pip3
sudo apt install python3-pip 
# Instala la versión 9.5.1 de Ansible con pip3 (Por reproducibilidad) 
sudo pip3 install ansible==9.5.1 --break-system-packages

Si estás en Windows, lamentablemente, no hay forma de ejecutar Ansible de forma nativa, tu mejor opción es habilitar WSL (Subsistema de Windows para Linux), instalar una distribución de Linux del Microsoft Store (recomiendo Ubuntu) y ejecutar los pasos anteriores en tu máquina virtual Linux.

Puedes encontrar una guía detallada para instalar WSL aquí y puede encontrar más información sobre la instalación de Ansible en el sitio de documentación oficial.

Además, dado que vamos a estar probando esto en una instancia EC2 con poca potencia, algunas de estas tareas van a tomar bastante tiempo y la conexión SSH podría cerrarse automáticamente por inactividad, para evitar esta situación, activa el envío de paquetes “keep-alive” al servidor editando el archivo ssh_config con sudo nano /etc/ssh/ssh_config y agregando estas dos líneas debajo de Host *:

    ServerAliveInterval 300
    ServerAliveCountMax 2

⚠️ Es muy importante no saltarse el paso anterior, de lo contrario, la conexión SSH fallará silenciosamente mientras se ejecutan tareas largas en Ansible y vas a estar esperando inútilmente con tu instancia EC2 sin hacer nada en realidad.

Descarga y Configura los Playbooks

Los playbooks están en un repositorio público en GitHub, puedes clonar el repositorio con estos comandos:

# Instala git si aún no lo tienes
sudo apt install git # En macOS usa `brew install git`
# Clona el último commit del repositorio
git clone https://github.com/andresrcs/aws_r_server.git --depth 1

Para comenzar a configurar los playbooks, por lo general, primero debes definir un “inventario” (una lista de servidores a los que conectarse), pero en este caso, el playbook provision_ec2_instance.yml creará uno automáticamente para ti cuando lo ejecutes y los otros playbooks obtendrán un inventario actualizado de AWS automáticamente usando el plugging aws_ec2 cuando sea necesario, esta es una de las ventajas de trabajar con servicios de computación en la nube bien soportados como AWS, pero para que el plugging aws_ec2 pueda hacer su magia, debes proporcionarle tus credenciales de AWS y definir tu región de AWS EC2, así que edita el archivo aws_r_server/inventories/aws_ec2.yml, y completa tus credenciales y región en las variables respectivas. Recuerda que ya creaste estas credenciales en un paso anterior y guardaste un archivo .csv que las contiene, además, la región de AWS que configures aquí debe ser la misma que seleccionaste cuando comenzaste a crear tus credenciales.

---
plugin: aws_ec2

aws_access_key: 'tu_código_de_acceso_va_aqui'
aws_secret_key: 'tu_código_secreto_va_aqui'

regions:
  - 'regin_aws_más_cercana' # Por ejemplo sa-east-1

hostnames:
  - 'ip-address' # No cambies esto

keyed_groups:
  - key: tags.inventory_group

Ahora, si deseas cambiar la configuración de instalación predeterminada, puedes hacerlo editando las variables en el archivo aws_r_server/vars/config_vars.yml, aunque las opciones predeterminadas están bien para la mayoría de los casos de uso, incluida una configuración de seguridad razonable para usar en aplicaciones del mundo real. Lo único que debes cambiar aquí son las credenciales de AWS, la región de AWS, la AMI de AWS (esto cambia constantemente incluso para la misma version del sistema operativo), el usuario personal y su contraseña, y la contraseña del usuario principal de PostgreSQL.

✏️ Esta publicación se ha escrito como un ejemplo de la aplicación de este enfoque con servicios de computación en la nube, por lo que, en aras de la simplicidad, lo hice funcionar solo con la AMI de Ubuntu Server 22.04 LTS, por lo que, para ser claro, no es independiente del sistema operativo. Si deseas utilizarlo con una AMI basada en RHEL, deberás modificar considerablemente los playbooks.

---
# Variables de Congiguración de AWS ############################################

# Credenciales de AWS
aws_access_key: 'tu_código_de_acceso_va_aqui'
aws_secret_key: 'tu_código_secreto_va_aqui'

# Configuración General de AWS
aws_region: 'regin_aws_más_cercana' # Por ejemplo sa-east-1
aws_ec2_ami: 'ami-08ae71fd7f1449df1' # Ubuntu 22.04 LTS

# Lista de instancias
instances:
  - name: rstudio
    group: aws
    security_group: ["default", "public_server"]
    ssh_key: aws_server
    type: 't2.micro'

# Configuración del firewall de AWS
security_groups:
  - name: public_server
    rules:
      - proto: tcp # http
        from_port: 80
        to_port: 80
        cidr_ip: 0.0.0.0/0
      - proto: tcp  # https
        from_port: 443
        to_port: 443
        cidr_ip: 0.0.0.0/0
      - proto: tcp  # SSH TCP
        from_port: 22
        to_port: 22
        cidr_ip: 0.0.0.0/0
      - proto: udp  # SSH UDP
        from_port: 22
        to_port: 22
        cidr_ip: 0.0.0.0/0
      - proto: tcp  # PostgreSQL
        from_port: 5432
        to_port: 5432
        cidr_ip: 0.0.0.0/0
    rules_egress: []

# Configuraciones del Sistema ##################################################

# Usuario Personal
personal_user: 'tu_usuario_de_linux'
personal_user_password: 'password_muy_seguro'

# Parametros Swap
swap_file_path: /var/swap
# Use any of the following suffixes
# c=1
# w=2
# b=512
# kB=1000
# K=1024
# MB=1000*1000
# M=1024*1024
# xM=M
# GB=1000*1000*1000
# G=1024*1024*1024
swap_file_size: 3GB
swappiness: '10'

# Lenguaje y configuración local
language_pack: []                 #  Por ejemplo language-pack-es-base
default_locale: 'en_US.UTF-8'     #  Por ejemplo es_PE.UTF-8

# Configuraciones de Seguridad #################################################

# Password para Postgresql
postgres_password: 'password_muy_seguro'

# Reglas de acceso para Postgresql
postgresql_rules:
  - { contype: local, users: all, address: samehost, method: trust }
  - { contype: local, users: postgres, address: samehost, method: trust }
  - { contype: host, users: all, address: 0.0.0.0/0, method: password }
  - { contype: host, users: all, address: 127.0.0.1/32, method: md5 }
  - { contype: host, users: all, address: '::1/128', method: trust }

# Versiones del Software Principal #############################################

# Versión de Shiny-server a instalar
shiny_server_version: '1.5.19.995'

# Versión de RStudio a instalar
rstudio_version: '2022.07.1+554'
preview_version: false

Ejecuta los Playbooks

Simplemente puede acceder a la carpeta aws_r_server y ejecutar el playbook main.yml para instalar todo a la vez de esta manera:

cd aws_r_server
ansible-playbook main.yml

Pero para hacer que el proceso de instalación sea más flexible, he dividido el proceso en cuatro playbooks individuales:

ansible-playbook provision_ec2_instance.yml
ansible-playbook install_basic_services.yml
ansible-playbook install_shiny_server.yml
ansible-playbook install_rstudio_server.yml

⚠️ Al aprovisionar la instancia ec2, la API de AWS a veces no devuelve la IP de la instancia, lo que hace que falle el playbook. Este es un error aleatorio no causado por el playbook, puedes ignorarlo con seguridad si estás ejecutando playbooks individuales y la instancia ya se ha aprovisionado.

Si decides que solo necesitas Shiny server o RStudio server pero no el otro, o si ya has instalado los servicios de soporte que vas a utilizar, puedes ejecutar solo los playbooks que realmente necesitas.

Si deseas actualizar algo en el futuro, como RStudio o Shiny (no puedo garantizar que siempre funcionará sin necesidad de cambios), simplemente puedes cambiar la versión en el archivo de configuración y ejecutar la parte específica del playbook aprovechando las “etiquetas” definidas.

Por ejemplo, esto solo instalará la versión de RStudio definida en el archivo de configuración y nada más:

ansible-playbook install_rstudio_server.yml --tags "rstudio"

Las etiquetas disponibles son:

install_basic_services.yml
- secure: Establecer la configuración de seguridad en el servidor
- swap: Agregar memoria swap al servidor
- nginx: Instalar y configurar Nginx + PHP
- postgresql: Instalar y configurar PostgreSQL
- r: Instalar R desde el repositorio CRAN
install_shiny_server.yml
- shiny-server: Instalar shiny-server
- configure_shiny: Configurar shiny-server
install_rstudio_server.yml
- rstudio: Instalar RStudio server
- configure_rstudio: Configurar RStudio server

También puedes hacer lo contrario y omitir partes específicas de los playbooks usando la opción --skip-tags, por ejemplo, si no necesitas PostgreSQL, puedes evitar instalarlo ejecutando el playbook de esta manera:

ansible-playbook install_basic_services.yml --skip-tags "postgresql"

Después de ejecutar con éxito todos los playbooks, tendrás una instalación completamente funcional lista para ser utilizada, por lo que podras simplemente abrir una sesión de RStudio en http://ip_de_tu_servidor/rstudio/ y/o publicar tus aplicaciones Shiny en la carpeta /srv/shiny-server y acceder a ellas en http://ip_de_tu_servidor/shiny/nombre_de_tu_app.

Notas Finales

Para terminar, solo quiero informarte que hay otras opciones para obtener RStudio y Shiny server en AWS que podrías considerar más simples, como usar una AMI o contenedores prefabricados, pero no son tan flexibles y personalizables como definir tu propia infraestructura en código con Ansible. Obviamente, el ejemplo de este artículo es mi concepción de una instalación básica para un servidor de ciencia de datos basado en R, pero puedes usarlo como punto de partida para personalizar tu propia infraestructura y hacer que tu flujo de trabajo sea más eficiente a medida que te vuelvas más competente con Ansible.

Instalación automática de Shiny y RStudio server en Raspberry Pi con Ansible

Wed, 13 Jan 2021 00:00:00 +0000

Tengo una publicación relacionada sobre la instalación manual de Shiny y RStudio Server en una Raspberry Pi, pero incluso con los últimos avances en el soporte de software para la arquitectura ARM, este proceso aún consume mucho tiempo y requiere mucho copiar/pegar y observar la terminal esperando que se complete una tarea para poder comenzar con la siguiente, así que decidí idear una mejor solución, y es automatizar el proceso para que pueda dejarse desatendido y regresar más tarde cuando haya terminado.

Para automatizar el proceso de instalación y configuración, decidí usar Ansible, aquellos en DevOps deben estar familiarizados con el poder de Ansible, pero incluso si nunca has escuchado de ello, no te preocupes, no necesitas conocer Ansible para aprovechar sus capacidades de automatización, yo mismo no soy un experto en Ansible y he sido capaz de realizar este proyecto con solo conocimientos básicos de la herramienta, así que si yo puedo hacerlo, tú también puedes. Te guiaré a través del proceso asumiendo que no tienes experiencia previa con esta herramienta y solo algunas habilidades básicas de terminal de Linux.

Ansible es una herramienta de implementación de aplicaciones, administración de configuración y aprovisionamiento de software de código abierto que habilita la infraestructura como código. Se ejecuta en muchos sistemas de tipo Unix y puede configurar tanto sistemas tipo Unix como Microsoft Windows. En términos simples, te permite automatizar tareas en tu infraestructura (una, o muchas Raspberry Pi a la vez en nuestro caso) definiendo un conjunto de pasos para ejecutar en archivos YAML llamados “playbooks”. Me sacrifique por el equipo y escribí algunos playbooks de Ansible para automatizar la mayor parte del proceso de instalación, pero dejando algo de espacio para que configures la instalación a tu gusto a través de un archivo de configuración, por lo que no necesitas modificar los playbooks (lo que requerirá que sepas cómo funcionan). Aunque, si deseas tener una comprensión básica de cómo funciona esta herramienta, hay una buena serie de Ansible para principiantes en el canal de YouTube de Jeff Geerling y si eres el tipo de personas que prefiere leer en lugar de ver cosas, aquí hay un Tutorial de Ansible para principiantes bastante agradable pero lamentablemente, está sólo en inglés.

✏️ Ten en cuenta que esto solo se ha probado con las versiones de software especificadas en el archivo config_vars.yml, es muy probable que funcione aún con las versiones de software más nuevas, pero en algunos casos, podría requerir algunas modificaciones a los playbooks, las que haré tan pronto como note el problema.

Prepara la Raspberry Pi

Incluso si la mayor parte del proceso se puede automatizar con Ansible, aún necesitamos al menos una Raspberry Pi en funcionamiento para configurar, por lo tanto, debemos comenzar cargando un sistema operativo (SO) en una tarjeta SD (recomiendo al menos 32 GB clase 10 HC1). Ten en cuenta que RStudio Server es compatible solo con los sistemas operativos arm64, por lo que si deseas poder instalarlo, deberás elegir un sistema operativo de 64 bits, los playbooks funcionan tanto con Raspberry Pi OS como con Ubuntu.

Descarga “Raspberry Pi Imager” del sitio oficial e instálalo en tu sistema, ejecuta “Raspberry Pi Imager”, selecciona un sistema operativo adecuado, elije tu “Tarjeta SD” y presiona “Escribir”.

Una vez finalizado el proceso, tendras una instalación limpia de un sistema operativo en tu tarjeta micro SD, inserta la tarjeta en tu Raspberry Pi, conecta un teclado y una pantalla y enciéndela.

Inicia sesión en el sistema (el usuario y la contraseña predeterminados son pi y raspberry para Raspberry Pi OS, y en Ubuntu es ubuntu tanto para el usuario como para la contraseña) y ejecuta una actualización inicial del sistema con estos comandos:

sudo apt update
sudo apt dist-upgrade

A continuación, debes configurar una IP estática para que puedas encontrar tu Pi fácilmente en tu red más adelante.

Para configurar una IP estática en Raspberry Pi OS, ejecuta estos comandos. Esta es una configuración de IP de muestra para una conexión por cable, modificala de acuerdo a tus propias necesidades:

# Configuración IP de muestra:
sudo nmcli c mod 'Wired connection 1' ipv4.addresses 192.168.3.101/24 ipv4.method manual
sudo nmcli con mod 'Wired connection 1' ipv4.gateway 192.168.3.1
sudo nmcli con mod 'Wired connection 1' ipv4.dns "192.168.3.1"
sudo nmcli c down 'Wired connection 1' && sudo nmcli c up 'Wired connection 1'

Luego debes volver a establecer una nueva conexión SSH con tu Pi ya que el IP ha cambiado.

Y para configurar la IP en Ubuntu, debes crear este archivo, sudo nano /etc/netplan/01-netcfg.yaml, agregar el siguiente contenido (edita según sea necesario) y aplicar la configuración con sudo netplan apply.

network:
    version: 2
    renderer: networkd
    ethernets:
        eth0:
            dhcp4: false
            addresses:
                - 192.168.3.101/24
            nameservers:
                addresses: [8.8.8.8, 8.8.4.4, 192.168.3.1]
            routes:
                - to: default
                  via: 192.168.3.1

Luego necesitamos establecer algunas configuraciones básicas con raspi-config. Ejecuta sudo raspi-config y realiza las siguientes tareas (en Ubuntu debes instalarlo primero con sudo apt install raspi-config):

Opcionalmente, cambia la contraseña del usuario “pi” (System Options –> Password)
Habilita el servidor SSH (Interface Options –> SSH)
Establece tu configuración regional (Localization Options)
Expande el sistema de archivos para utilizar la capacidad total de tu tarjeta SD (Advanced Options –> Expand Filesystem)
Deshabilita los nombres de interfaz de red predecibles (Advanced Options –> Network Interface Names)

Cuando hayas terminado, sal de la herramienta raspi-config y reinicia tu Pi.

Si no tienes una, debes crear una clave SSH, incluso si es posible usar Ansible proporcionando una contraseña para tus hosts de forma interactiva, una forma más conveniente y segura de hacerlo es usando un par de claves SSH. Para crear una, ejecuta los siguientes comandos en la terminal:

# Crea la carpeta .ssh
cd ~
mkdir .ssh
cd .ssh
# Crea el archivo authorized_keys
touch authorized_keys

# Establece permisos de acceso adecuados
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

# Crea el par de claves
ssh-keygen
# Agregua la nueva clave al archivo authorized_keys
cat id_rsa.pub >> authorized_keys

# Si usas Putty como tu cliente SSH (Windows), genera una clave ppk; de lo contrario, ignora estos pasos
sudo apt install putty-tools
puttygen id_rsa -o id_rsa.ppk

Copia los archivos id_rsa e id_rsa.pub (id_rsa.ppk si corresponde) a la máquina que va a usar para ejecutar los playbooks, a mí me gusta usar sftp pero puedes hacerlo de la manera que prefieras (por ejemplo, con una memoria USB). Después de haber copiado los archivos de clave, elimínalos de tu Pi con rm ~/.ssh/id_rsa*. Si ya tienes una clave SSH, confío en que sabes cómo agregarla a tu sistema operativo en el momento de cargarlo con Raspberry Pi Imager.

Ahora tu Pi está lista, desconecta el teclado y el monitor, conecta la Raspberry Pi a tu red (recomiendo usar una conexión por cable).

Instala Ansible

En teoría, podrías instalar Ansible en la propia Raspberry Pi y ejecutar los playbooks directamente en ella con connection: local pero no sería práctico, es mejor ejecutar los playbooks desde una computadora que no sea tu Raspberry Pi.

Para instalar Ansible, si tienes un sistema basado en Unix (es decir, Linux, macOS) a tu disposición, tienes suerte, instalar Ansible es muy simple.

# Instala python3
sudo apt install python3 # En macOS usa `brew install python3`
# Instala pip3
sudo apt install python3-pip 
# Instala la versión 9.5.1 de Ansible con pip3 (Por reproducibilidad) 
sudo pip3 install ansible==9.5.1 --break-system-packages

Puedes encontrar una guía detallada para instalar WSL aquí y puede encontrar más información sobre la instalación de Ansible en el sitio de documentación oficial.

Además, dado que vamos a estar instalando varios paquetes desde la fuente en una SBC de baja potencia, algunas de estas tareas van a tomar bastante tiempo y la conexión SSH podría cerrarse automáticamente por inactividad, para evitar esta situación, activa el envío de paquetes “keep-alive” al servidor editando el archivo ssh_config con sudo nano /etc/ssh/ssh_config en la computadora que está ejecuntado Ansible y agregando estas dos líneas debajo de Host *:

    ServerAliveInterval 300
    ServerAliveCountMax 2

⚠️ Es muy importante no saltarse el paso anterior, de lo contrario, la conexión SSH podría fallar silenciosamente mientras se ejecutan tareas largas en Ansible y vas a estar esperando inútilmente con tu Raspberry Pi sin hacer nada en realidad.

Descarga y configura los Playbooks

Los playbooks están en un repositorio público en GitHub, puedes clonar el repositorio con estos comandos:

# Instala git si aún no lo tienes
sudo apt install git
# Clonar el último commit del repositorio
git clone https://github.com/andresrcs/raspberry_pi_server.git --depth 1

Ansible no ejecuta playbooks en “carpetas de escritura global”, por lo que debes configurar los permisos de la carpeta raspberry_pi_server en 755.

sudo chmod 755 raspberry_pi_server

Ten en cuenta que en WSL es necesario volver a montar la unidad C para poder cambiar los permisos de los archivos, por lo que debes hacer esto antes de cambiar los permisos:

sudo umount /mnt/c 
sudo mount -t drvfs C: /mnt/c -o metadata

Para configurar los playbooks, primero debes definir tu “inventario”, esta es una lista de los hosts a los que te vas a conectar, edita el archivo raspberry_pi_server/inventory.ini y agrega la IP de tu(s) Raspberry Pi(s):

[raspberries] # Esto representa un grupo de Raspberries
raspberry_01 ansible_host=192.168.3.101 # Este es el nombre de host y la IP de una Raspberry Pi individual
# Puedes agregar tantas Raspberries como necesites

Luego, configura las variables comunes para el grupo [raspberries] editando el archivo raspberry_pi_server/group_vars/raspberries.yml, lo más importante para verificar aquí es la ruta a tu clave ssh y el usuario predeterminado para el sistema operativo que estes usando.

---
ansible_user: pi # Este es el usuario predeterminado para el sistema operativo
ansible_become_method: sudo
ansible_python_interpreter: /usr/bin/python3
ansible_ssh_private_key_file: ~/.ssh/raspberrypi_key # La ubicación de la clave ssh en la computadora que está ejecuntando Ansible.

Ahora, puedes configurar las opciones de instalación editando las variables en el archivo raspberry_pi_server/vars/config_vars.yml, las opciones ya configuradas están bien para la mayoría de los casos de uso, incluidas configuraciones de seguridad razonables, pero como mínimo, debes configurar tu contraseña personal para el usuario principal de PostgreSQL. También puedes elegir tu método preferido para instalar R, si no deseas usar la opción predeterminada, ten en cuenta que usar la opción R4Pi solo es posible con Raspberry Pi OS y siempre instalará la última versión de R disponible.

---
# Configuraciones del sistema ##################################################

# Parametros Swap
swap_file_path: '/var/swap.1'
# Utiliza cualquiera de los siguientes sufijos
# c=1
# w=2
# b=512
# kB=1000
# K=1024
# MB=1000*1000
# M=1024*1024
# xM=M
# GB=1000*1000*1000
# G=1024*1024*1024
swap_file_size: '3GB'
swappiness: '10'

# Instalar Nginx?
install_nginx: true

# Instalar PostgreSQL?
install_postgresql: true

# Configuraciones de seguridad #################################################

# Puertos para abrir
exposed_ports:
  - { rule: 'allow', port: 22, proto: 'tcp' }     # ssh
  - { rule: 'allow', port: 22, proto: 'udp' }     # ssh
  - { rule: 'allow', port: 80, proto: 'tcp' }     # http
  - { rule: 'allow', port: 5432, proto: 'tcp' }   # Postgresql (omitir si Postgresql no está instalado)
  - { rule: 'allow', port: 5432, proto: 'udp' }   # Postgresql (omitir si Postgresql no está instalado)
  # - { rule: 'allow', port: 8787, proto: 'tcp' } # RStudio Server (descomentar si Nginx no está instalado)
  # - { rule: 'allow', port: 3838, proto: 'tcp' } # Shiny Server (descomentar si Nginx no está instalado)

# Contraseña para el usuario principal de PostgreSQL
postgres_password: 'very_secure_password'

# Reglas de acceso para PostgreSQL
postgresql_rules:
postgresql_rules:
  - { contype: local, users: postgres, address: samehost, method: trust }
  - { contype: local, users: all, address: samehost, method: trust }
  - { contype: hostssl, users: all, address: 0.0.0.0/0, method: scram-sha-256 }
  - { contype: host, users: all, address: 0.0.0.0/0, method: scram-sha-256 }
  - { contype: hostssl, users: all, address: '::0/0', method: scram-sha-256 }
  - { contype: host, users: all, address: '::0/0', method: scram-sha-256 }
  - { contype: host, users: all, address: 127.0.0.1/32, method: scram-sha-256 }
  - { contype: host, users: all, address: '::1/128', method: scram-sha-256 }

# Versiones principales de software ############################################

# Versión de R a instalar
use_r4pi: true # Si se establece en verdadero, se instalará la última versión de R, esto solo es compatible con
                # Raspberry Pi OS.
use_rig: false # Si se establece en verdadero, no olvide especificar una versión R en la siguiente línea
r_version: '' # (e.g. '4.3.3') Actualmente, solo puede elegir la versión R si va a ser
                   # instalado con rig o compilado (con 'use_r4pi' y 'use_rig' establecidos como false).

# Versión de shiny-server a instalar
shiny_server_version: 'v1.5.21.1012'

# Versión del servidor rstudio-server a instalar
rstudio_version: '2024.04.0-daily+651'

Ejecuta los Playbooks

En condiciones ideales, como usando el último modelo de Raspberry Pi, con 8 GB de RAM, booteando desde un SSD, y conectado a una red estable, puedes simplemente acceder a la carpeta raspberry_pi_server y ejecutar el libro de jugadas site.yml para instalar todo de una sóla vez:

cd raspberry_pi_server
ansible-playbook site.yml

Pero en condiciones menos que ideales, es muy probable que encuentres algunos errores aleatorios causados por la sobrecarga de la Pi o conexiones de red inestables, por lo que, para mitigar este problema y hacer que el proceso de instalación sea más flexible, he dividido el proceso en tres playbooks individuales:

cd raspberry_pi_server
ansible-playbook install_basic_services.yml
ansible-playbook install_shiny_server.yml
ansible-playbook install_rstudio_server.yml

Si decides que solo necesitas el servidor Shiny o el servidor RStudio pero no el otro, o si ya has instalado los servicios de soporte que deseas, puedes ejecutar solo los playbooks que necesitas.

Si deseas actualizar algo en el futuro, como R, RStudio o Shiny server (no puedo garantizar que siempre funcionará sin necesidad de cambios), puedes simplemente cambiar la versión en el archivo de configuración y ejecutar la parte específica del playbook aprovechando las “etiquetas” definidas.

Por ejemplo, esto solo instalará la versión R definida en el archivo de configuración y nada más:

cd raspberry_pi_server
ansible-playbook install_basic_services.yml --tags "r"

Las etiquetas disponibles son:

install_basic_services.yml
- secure: Establecer la configuración de seguridad en el servidor
- swap: Agregar memoria swap al servidor
- nginx: Instalar y configurar Nginx + PHP
- postgresql: Instalar y configurar PostgreSQL
- r: Instalar R desde la fuente
- disable_wifi: Desactivar el módulo Wifi y Bluetooth
install_shiny_server.yml
- shiny-server: Instalar shiny-server desde la fuente
- configure_shiny: Configurar shiny-server
install_rstudio_server.yml
- rstudio: Instalar RStudio server desde la fuente
- configure_rstudio: Configurar RStudio server

cd raspberry_pi_server
ansible-playbook install_basic_services.yml --skip-tags "postgresql"

Después de ejecutar con éxito todos los playbooks, tendrás una instalación completamente funcional lista para ser utilizada, por lo que podras simplemente abrir una sesión de RStudio en http://ip_de_tu_servidor/rstudio y/o publicar tus aplicaciones Shiny en la carpeta /srv/shiny-server y acceder a ellas en http://ip_de_tu_servidor/shiny/nombre_de_tu_app.

⚠️ Si la configuración de Nginx no ha sido establecida por el playbook install_basic_services.yml porque lo has omitido, debes configurar el proxy inverso manualmente o acceder a los servicios con su puerto específico, por ejemplo http://your_server_ip/3838/your_app_name, esto también requiere que abras el puerto correspondiente en el firewall.

Notas Finales

Incluso con la automatización, la instalación de forma nativa llevará mucho más tiempo que, por ejemplo, con el uso de contenedores, especialmente si usas una Raspberry Pi con poca memoria RAM (< 4GB) pero como está automatizado, simplemente puedes dejar que se ejecute y volver más tarde, y disfrutarás de la facilidad de gestión de una instalación nativa.

Además, ten en cuenta que el proceso de instalación llevará tu Raspberry Pi a sus límites, por lo que puedes esperar algunos errores aleatorios, pero eso no significa que no va ha funcionar, simplemente reinicia tu Pi, vuelve a ejecutar el playbook problemático y ve si funciona la segunda vez. He hecho todo lo posible para que esto sea funcional a largo plazo estableciendo versiones de software específicas, pero aún es posible que una actualización de librerias del sistema inutilice los playbooks. Si encuentras algún problema, ve al repositorio de GitHub para los playbooks y registra un “issue”, o mejor aún, si sabes cómo solucionarlo, haz un “pull request”.

Como nota final, quiero señalar que este enfoque se puede extender aún más de acuerdo con tus propias necesidades, por ejemplo, puedes implementar la restauración automática de tu servidor, incluido el contenido desplegado. Por ejemplo, yo tengo un playbook adicional para restaurar las aplicaciones, servicios y bases de datos que normalmente ejecuto en mi Raspberry Pi, por lo que, en caso de una falla catastrófica, puedo volver a un estado operativo en un período corto de tiempo y con poco esfuerzo, comparado con hacer una restauración manual de mi sistema.

Personalizando la ubicación de tu librería de paquetes

Mon, 26 Oct 2020 00:00:00 +0000

Para los usuarios de R razonablemente experimentados, este simple tema puede no parecer digno de una publicación de blog, por lo que si no eres un principiante de R, es posible que desees omitir esta publicación. Dicho esto, he tenido que explicar esta tarea tantas veces en los foros de la comunidad R, que escribir una se vuelve obligatorio para evitar escribir el mismo texto una vez más.

Las razones para personalizar la ruta de tu biblioteca en lugar de seguir los valores predeterminados pueden ser variadas, pero para los principiantes de R, la más común es evitar problemas de instalación de paquetes debido a permisos de escritura, caracteres no ASCII en rutas de carpetas, carpetas sincronizadas en la nube o unidades de red, que conducen a mensajes de error como:

Warning in install.packages :
  'lib = "/path/to/your/library"' is not writable
Error in install.packages : unable to install packages

** byte-compile and prepare package for lazy loading
Error: unexpected symbol in "setwd('incomplete/path/to/your/library"
Execution halted

Muy a menudo, la solución a estos problemas es configurar tu biblioteca de paquetes en algún otro lugar de tu sistema, donde tengas los permisos adecuados y no existan incompatibilidades con R conocidas. La forma de cambiar la ubicación de una biblioteca de paquetes es configurarla manualmente en un archivo de inicio, es decir, archivos Rprofile.site y Renviron.site a nivel de versión R (ubicado en R_HOME/etc/) o archivos .Rprofile y .Renviron, a nivel de usuario (ubicado en su carpeta HOME) o a nivel de proyecto (ubicado en el directorio de trabajo actual).

✏️ Para obtener más información sobre los archivos de inicio de R, puedes leer el siguiente artículo de soporte.

Para archivos de tipo Renviron, se debe especificar la variable de entorno correspondiente, por ejemplo, si quiero cambiar los árboles de la biblioteca R en un sistema Linux, agregaría una línea como esta al archivo Renviron.site ubicado en /usr/lib/R/etc/ (En este caso, la variable de entorno R_HOME se traduce a /usr/lib/R/).

R_LIBS_SITE="/usr/lib/R/site-library:/usr/lib/R/library"

Siendo la primera ubicación desde la izquierda la predeterminada, que es utilizada por install.packages() si no se especifica el argumento lib, y todas ellas (que están separadas por dos puntos) se escanean en orden en busca de paquetes al iniciar R. Ten en cuenta que solo se incluirán los directorios que existan en ese momento.

Para archivos de tipo Rprofile, se debe usar la función .libPaths(), ya que estos archivos deben contener código R válido para ser ejecutados al inicar R. El comando R equivalente al ejemplo anterior sería:

.libPaths(c("/usr/lib/R/site-library", "/usr/lib/R/library"))

Obviamente, las rutas de las carpetas serán diferentes según tu sistema operativo y configuración específicos, pero espero que se entienda la idea general de que debes especificar una ruta de carpeta que sea adecuada para tus necesidades específicas, por ejemplo, en un sistema Windows el equivalente sería:

.libPaths(c("C:/Program Files/R/R-4.0.3/library"))

De forma predeterminada, la biblioteca de paquetes predeterminada se establece a nivel de usuario (carpeta HOME), lo que en algunos casos, puede causar los problemas mencionados anteriormente. Ahora, este es un consejo sesgado, pero para un uso individual simple, me resulta más práctico establecer la biblioteca de paquetes predeterminada a nivel de la versión R (carpeta R_HOME/library/) y hacer uso explícito de otras ubicaciones, de forma selectiva, y según los casos de uso específicos. Ten en cuenta que dependiendo de tu configuración de seguridad y sistema operativo, es posible que debas ejecutar tu sesión R con derechos de “administrador” o desde un usuario con derechos “sudo” para que esto funcione.

Alternativas para obtener datos de sensores desde microcontroladores compatibles con Arduino en R

Sun, 09 Feb 2020 00:00:00 +0000

¿Alguna vez ha querido obtener sus propios datos del mundo real utilizando sensores? Con la llegada del movimiento de Hardware Libre, esto se ha vuelto más accesible para el público en general, los microcontroladores y sensores se han vuelto más baratos y fáciles de programar con lenguajes amigables para los humanos como Arduino (C ++) y MicroPython (Python), por lo que ahora cualquiera puede producir sus propios datos sensoriales del mundo real, pero, todavía hay un problema, ¿cómo podemos obtener estos datos en R para poder analizarlos?

Dependiendo de los requisitos de su aplicación, puede elegir entre una gran cantidad de opciones. Por ejemplo, si solo necesita datos en lotes y puede tener fácil acceso físico a su dispositivo, simplemente puede agregar un módulo de tarjeta SD a su proyecto y registrar los datos en un archivo .csv en una tarjeta SD, pero eso no sería divertido, ¿verdad? Una solución mucho mejor sería obtener datos de forma remota y preferiblemente de forma inalámbrica, ¿no cree? Exploremos algunas opciones.

Conexión Serial

Si nunca antes ha pensado en obtener datos desde microcontroladores, apuesto a que el primer pensamiento que le viene a la mente es conectar directamente el microcontrolador con R para obtener los datos, pero esta es actualmente la opción más desafiante técnicamente, puede hacerse usando una conexión serial entre el microcontrolador y su computadora, pero que yo sepa, solo hay un paquete R implementando esto y solo se ejecuta en sistemas compatibles con POSIX (adiós Windows).

No puedo probar este enfoque yo mismo, ya que no tengo una máquina física Linux o macOS para conectar un microcontrolador, por lo que para este caso, solo voy a referirlos a una publicación de blog por @haozhu233 (el autor del paquete) mostrando su funcionalidad.

Si su aplicación requiere adquisición de datos en tiempo real o una latencia muy baja, esta podría ser su única opción y es posible que desee profundizar en esto.

Streaming arduino sensor signals right into @rstudio! I wonder if there is really anything #rstats can’t do 😎😎😎 pic.twitter.com/nT6q6TT6xc
— Hao Zhu (@haozhu233) January 25, 2019

Guardar en un Servidor SQL

Hay dos formas de hacer esto, una es conectar directamente el microcontrolador a la base de datos y la otra es usar otro servicio para extraer datos del microcontrolador y escribirlos en la base de datos.

La primera opción es más difícil de lograr, que yo sepa, solo hay una biblioteca Arduino que proporciona un conector SQL para servidores MySQL, pero no hay soluciones ya hechas para otros servidores SQL y, aunque podría escribir su propio conector para otros servidores SQL de código abierto (como PostgreSQL), eso requeriría una considerable cantidad de habilidades técnicas.

La segunda opción es más fácil de implementar, y mi favorito personal.

El primer paso es transmitir los datos desde el microcontrolador, una forma de hacerlo es implementar un servidor web simple en el microcontrolador y servir los datos en un formato adecuado como HTML, JSON o CSV.

Este es un ejemplo simple de un Sketch Arduino para una placa ESP8266 (Wemos D1 mini) y sensores de temperatura tipo sonda DS18B20, que sirve salidas HTML y JSON a través de un servidor web.

El segundo paso es extraer los datos del microcontrolador y ponerlos en un servidor SQL, hay muchos enfoques y lenguages que puede usar para implementar esta parte, pero obviamente vamos a usar R. Puede escribir un script R que se conecte al microcontrolador, recupere los datos y los escriba en un servidor SQL, y programar el script con un trabajo cron.

#! /usr/bin/env Rscript

# ADQUISICIÓN DE DATOS #########################################################
raw_data <- rjson::fromJSON(file="http://192.168.0.102/reading.json") 
current_time <- as.character(Sys.time())

# PARAMETROS ###################################################################
current_location = "some_place"
point_names = c("probe0" = "measurement_point_0", 
                "probe1" = "measurement_point_1",
                "probe2" = "measurement_point_2")

# LIBRERIAS ####################################################################
library(dplyr)

# DATA CLEANING ################################################################
tidy_data <- as_tibble(raw_data) %>%
    tidyr::gather(measurement_point, value) %>% 
    mutate(time = current_time,
           location = current_location,
           variable = stringr::str_extract(measurement_point, "^.+(?=-)"),
           measurement_point = stringr::str_extract(measurement_point, "(?<=-).+$"),
           measurement_point = stringr::str_replace_all(measurement_point, point_names)
           ) %>%
    select(time, location, variable, measurement_point, value)

# CARGAR DATOS #################################################################
con <- dbConnect(drv = odbc::odbc(),
                 driver = 'PostgreSQL ANSI',
                 server = 'localhost',
                 database = 'sensors',
                 port = 5432,
                 uid = Sys.getenv('MY_UID'),
                 pwd = Sys.getenv('MY_PWD'),
                 encoding = 'utf8')

DBI::dbAppendTable(conn = con,
                   name = 'sensors_data',
                   value = tidy_data)

odbc::dbDisconnect(con)

unlink(x = "*.log", force = TRUE)

Ahora que tiene los datos en un servidor SQL, está en una consulta SQL de distancia de tenerlos en R

library(odbc)

con <- dbConnect(drv = odbc::odbc(),
                 driver = 'PostgreSQL ANSI',
                 server = 'localhost',
                 database = 'sensors',
                 port = 5432,
                 uid = Sys.getenv('MY_UID'),
                 pwd = Sys.getenv('MY_PWD'),
                 encoding = 'utf8')

query <- "
    SELECT * 
    FROM public.sensors_data
    "

raw_data <- dbGetQuery(
  conn = con,
  statement = query
)

dbDisconnect(con)

Lo que hace que este enfoque sea mi favorito personal es que es fácil de implementar, muy flexible y le permite implementar casi cualquier medida de seguridad que pueda necesitar.

Usando el Protocolo MQTT

Para aplicaciones con recursos más limitados, puede usar un enfoque similar al anterior, pero con una tecnología diferente, el protocolo MQTT es ideal para dispositivos de baja potencia en conexiones lentas y poco confiables, además, esta es también una forma de obtener datos de redes LoRa como la disponible públicamente TTN (The Things Network) que proporciona una API sobre MQTT, que le da acceso a una red de área amplia de baja potencia para la implementación remota de sensores a mayores distancias.

Este enfoque también le permite escribir datos en un servidor SQL como en el ejemplo anterior, pero una aplicación más interesante para esto sería obtener actualizaciones de estado instantáneas para mostrar en Dashboards o aplicaciones Shiny. Considere esta sencilla aplicación Shiny que recibe un mensaje de un sensor remoto simulado y actualiza el color de un círculo en consecuencia, puede actualizar el valor de temperatura del sensor simulado enviando un mensaje MQTT al tema de prueba desde una terminal de sistema en cualquier computadora con este comando mosquitto_pub -h test.mosquitto.org -t simulated_sensor -q 1 -m 25.9 -r y ver cómo cambia el color.

✏️ Para que esto funcione, debe tener el cliente mosquitto instalado en su sistema.

sudo apt install mosquitto-clients

library(shiny)
library(ggplot2)
library(rmqtt)  # Este paquete es simplemente una envoltura para un cliente MQTT que usa
                # llamadas al sistema `system()`, necesita tener el cliente mosquitto
                # instalado en su sistema para que esto funcione.

# Inicializar el sensor simulado
mqtt_topic_publish(
    topic = "simulated_sensor", 
    message_to_send = "24.9",
    host = "test.mosquitto.org",
    port = 1883,
    qos = 1, 
    retain_message = TRUE
)

ui <- fluidPage(
    titlePanel("Dashboard"),
    mainPanel(
        h2("Indicador de Temperatura"),
        plotOutput("indicator_estado")
    )
)

server <- function(input, output, session) {
    
    get_color <- function() {
        message <- mqtt_topic_subscribe(
            topic = "simulated_sensor", 
            host = "test.mosquitto.org",
            port = 1883,
            qos = 1,
            intern = TRUE,
            num.messages = 1
        )
        
        if (as.numeric(message) > 25) {
            color = 'red'
        } else {
            color = 'green'
        }
        
        return(color)
    }
    
    pollData <- reactivePoll(100, session,
                             checkFunc = get_color,
                             valueFunc = get_color
    )
    
    output$indicator_estado <- renderPlot({
        ggplot(data = data.frame(x = 1, y = 1), aes(x, y)) +
            geom_point(size = 50, color = pollData()) +
            scale_x_discrete() +
            scale_y_discrete() +
            theme_void() +
            theme(axis.title = element_blank())
    })
}

shinyApp(ui = ui, server = server)

Si está interesado en probar esto, aquí hay un GitHub Gist con el Sketch Arduino para una placa ESP8266 con un sensor de temperatura tipo sonda DS18B20 que puede actualizar los valores en la aplicación de ejemplo.

Sé que esto no parece muy interesante en este momento, pero tenga en cuenta las implicaciones. ¡Podría recibir actualizaciones instantáneas en su Dashboard de sensores desplegados a kilómetros de distancia e incluso podría controlar actuadores remotos desde su aplicación Shiny enviando un mensaje MQTT desde ella con solo hacer clic en un botón!

La desventaja de este método es que debe configurar un agente MQTT (no debe abusar de los disponibles públicamente que están destinados a pruebas), pero se puede hacer con poco o ningún dinero en una Raspberry Pi o una instancia EC2 AWS.

Descargo

Quiero dejar en claro que esta no es una lista exhaustiva, hay otras alternativas e innumerables variaciones de las que se presentan aquí, así que si ninguna de estas se ajusta a las necesidades de su proyecto en particular, siga buscando, es muy probable que alguien haya encontrado una método más adecuado.

✏️ Si desea ver un ejemplo detallado paso a paso de cualquiera de estas opciones, escríbalo en los comentarios e intentaré hacer una publicación de blog al respecto.

Monitoreando su velocidad real de Internet a lo largo del tiempo, utilizando R y Speedtest-CLI

Tue, 21 Jan 2020 00:00:00 +0000

Pensé que esto solo sucedía en mi país (Perú), pero resulta que les sucede a personas en todo el mundo, uno contrata un plan de Internet que ofrece hasta X Mbps, donde X es un valor impresionante (relativo al contexto de cada país), pero la trampa está en esa palabra, Hasta.

If it makes you feel better, it could be worse if you lived in another country, trust me, I know... pic.twitter.com/Rm3J2J2Cdz
— Andrés Castro Socolich (@Andresrcs) January 16, 2020

En realidad, termina obteniendo velocidades de descarga mucho más lentas de lo anunciado, y los ISP (Proveedores de Servicios de Internet por sus siglas en inglés) se salen con la suya, ya que solo prueban la velocidad de descarga con usted, una vez, cuando instalan el servicio (sospechosamente funciona muy bien en ese momento) y la mayoría de personas no se molestan en realizar un seguimiento de sus velocidades de descarga a lo largo del tiempo, ya que no es práctico realizar pruebas de velocidad manualmente cada corto período de tiempo, afortunadamente hay una mejor manera, el servicio Speedtest de Ookla provee una Interfaz de Línea de Comandos (CLI por sus siglas en inglés), que le permite realizar pruebas desde la terminal de su sistema, dándole la capacidad de configurar scripts automáticos para recopilar datos de rendimiento de la conexión.

En las siguientes líneas, le mostraré cómo hacer esto desde R y obtener los resultados en forma de bonitos gráficos que puede twittear a su ISP para molestarlos un poco. 😆

Preparando su Configuración

Tenemos que configurar nuestro entorno de trabajo para este proyecto. Primero, necesitamos una máquina que esté constantemente encendida y conectada a la misma conexión de Internet que desea probar, para que pueda realizar las pruebas y almacenar los datos, podría ser cualquier computadora conectada a su red local pero la solución más práctica (y económica) que he encontrado es usando una Raspberry Pi, así que usaré una para este proyecto.

Dado que está leyendo un artículo relacionado con R, voy a suponer que ya tiene su entorno de R básico configurado, por lo que nos centraremos en las cosas adicionales, necesitamos instalar la interfaz de línea de comandos (CLI) de Speedtest, si está en una máquina Linux, puede hacerlo con estos comandos en una terminal del sistema:

✏️ Hay instrucciones de instalación para otros sistemas operativos en el sitio web de Speedtest.

sudo apt-get install curl
curl -s https://packagecloud.io/install/repositories/ookla/speedtest-cli/script.deb.sh | sudo bash
sudo apt-get install speedtest

✏️ Compruebe si tiene instalada una versión anterior Python de la CLI en su sistema y asegúrese de desinstalarla con este comando sudo pip uninstall speedtes-cli, ya que podría causar conflictos con la versión oficial más reciente. Esto me sucedió y no me di cuenta 😳, gracias a @jasongrahn por el aviso.

Reuniendo Dato

Ahora podemos escribir un script R que recupere el resultado de la prueba, procese el contenido y almacene los datos. En este ejemplo, los voy a almacenar en una base de datos PostgreSQL, pero podría elegir otras opciones como otro servidor SQL, Hojas de cálculo de Google, un archivo CSV, etc. He llamado a este script speedtest_job.R.

#! /usr/bin/env Rscript

# Data adquisition
output <- read.csv(
  text = system(
    command = "speedtest -f csv --output-header --accept-license",
    intern = TRUE
  )
)

results <- data.frame(
  stringsAsFactors = FALSE,
  time = as.POSIXct(Sys.time()),
  ip = system("curl ifconfig.me", intern = TRUE), # This field is no longer provided on the new CLI version
  ping = output$latency,
  download = output$download * 7.629395E-6, # Convert to Mbps
  upload = output$upload * 7.629395E-6, # Convert to Mbps
  isp = "movistar" # This field is not provided on CSV format
)

# Data storing
con <- dbConnect(drv = odbc::odbc(),
                 driver = 'PostgreSQL ANSI',
                 server = 'localhost',
                 database = 'internet', # Name of the database on the sql server
                 port = 5432,
                 uid = Sys.getenv('MY_UID'),
                 pwd = Sys.getenv('MY_PWD'),
                 encoding = 'utf8')

DBI::dbAppendTable(
  conn = con,
  name = "speed_test", # Table name on the sql server
  value = results
)

odbc::dbDisconnect(conn = con)

# Cleaning log files
unlink(x = "*.log", force = TRUE)

Ahora podemos programar un trabajo cron para ejecutar este script a intervalos regulares, voy a configurarlo para que se ejecute una vez cada hora ejecutando estos comandos en un terminal del sistema:

✏️ Esto también se puede hacer desde R usando el paquete cronR.

env EDITOR=nano crontab -e
  # Agregue esta línea
  0 * * * * /usr/local/lib/R/bin/Rscript '/home/pi/speedtest_job.R' >> '/dev/null' 2>&1 # Modifique la ruta del archivo según sea necesario. 
sudo service cron reload

Después de dejar pasar un tiempo para que se acumulen los registros, podemos obtener datos del servidor con una consulta SQL:

library(odbc)

con <- dbConnect(drv = odbc::odbc(),
                 driver = 'PostgreSQL ANSI',
                 server = Sys.getenv('MY_REMOTE'),
                 database = 'internet',
                 port = 5432,
                 uid = Sys.getenv('MY_UID'),
                 pwd = Sys.getenv('MY_PWD'),
                 encoding = 'utf8')

query <- "
    SELECT * 
    FROM public.speed_test 
    ORDER BY time
    "

raw_data <- dbGetQuery(
  conn = con,
  statement = query
)

dbDisconnect(con)

Visualizando los Datos

Ahora que tenemos algunos datos para trabajar, podemos comenzar a hacer algunos gráficos. Dado que este no es un artículo sobre ggplopt2, no voy a entrar en detalles sobre esta parte, solo voy a mostrar algunos gráficos interesantes que puede obtener sobre la velocidad de su conexión a Internet.

En la Figura 1 podemos ver cómo se distribuyen las velocidades de descarga observadas, dejando de lado el hecho de que la velocidad anunciada ya es lenta (para los estándares de los países desarrollados), esto revela un patrón que es muy común, la mayoría de las veces usted obtiene velocidades de descarga que son mucho más lentas de lo anunciado por el ISP e incluso tan lentas que no cumplen con los términos de su contrato, como en mi caso (en realidad usé esta imagen para presentar una queja).

library(tidyverse)
library(xkcd)
library(lubridate)
library(tibbletime)
library(scales)

# Estas son mis configuraciones de tema personales, puede ignorarlas si lo prefiere
theme_set(
  theme_gray() +
    theme_xkcd() +
    theme(legend.position = "right",
          plot.title.position = "plot",
          axis.title.x = element_text(margin = margin(t = 10)),
          axis.title.y = element_text(margin = margin(r = 10)),
          axis.text.x = element_text(angle = 20, hjust = 1, vjust = 1),
          plot.margin = margin(10, 10, 10, 10),
          text = element_text(family = "Cloud Calligraphy"))
)

color <- c("Moda" = "#008B00", "Parámetros" = "orange")

raw_data %>% 
  ggplot(aes(x = download)) +
  geom_histogram(binwidth = 0.1, fill = "#00B2EE") +
  geom_vline(aes(xintercept = 20, color = "Parámetros"),  linetype = "dashed") +
  geom_vline(aes(xintercept = 8, color = "Parámetros"),  linetype = "dashed") +
  stat_bin(geom = "vline",
           aes(xintercept = stat(ifelse(count == max(count), x, NA)),
               color = "Moda"),
           binwidth = 0.1) +
  annotate("text",
           x = c(8.4, 20.4),
           y = c(8, 8),
           label = c("Velocidad Mínima Garantizada", "Velocidad Ofrecida"),
           family = "Cloud Calligraphy",
           size = 5,
           angle = 90) +
  stat_bin(geom = "label",
           aes(label = stat(ifelse(count == max(count), round(x, 1), NA))),
           binwidth = 0.1,
           family = "xkcd",
           color = "#008B00",
           vjust = -0.2) +
  labs(title = 'HISTOGRAMA DE VELOCIDADES DE DESCARGA OBSERVADAS',
       subtitle ='ISP: MOVISTAR 20 Mbps', 
       x = 'Velocidad (Mbps)',
       y = 'Frecuencia',
       colour = '') +
  scale_x_continuous(breaks = seq(0, 22, by = 2),
                     limits = c(0, 23)) +
  scale_colour_manual(values = color) +
  coord_cartesian(clip = 'off') +
  NULL

Figure 1: Histograma de Velocidades de Descarga Observadas

Con las Figuras 2 y 3, podemos mostrar con qué frecuencia las velocidades de descarga caen por debajo de la velocidad mínima garantizada.


colors <- c("Velocidad Promedio" = "blue",
            "Parámetros" = "orange",
            "Falla" = "red",
            "Velocidad de Descarga" = "#00B2EE")

plot_data <- raw_data %>%
  as_tbl_time(index = time) %>% 
  collapse_by('1 hour', side = 'start', clean = TRUE)

mean_speed <- plot_data %>% 
  pull(download) %>% 
  mean() %>%
  round(1)

plot_data %>% 
  ggplot(aes(x = time, y = download)) +
  geom_line(aes(color = "Velocidad de Descarga")) +
  geom_point(data = plot_data %>% filter(download < 8),
             aes(color = "Falla")) +
  geom_point(data = plot_data %>% filter(download < 8),
             shape = 1,
             color = "red",
             size = 5) +
  geom_hline(aes(yintercept = 20, color = "Parámetros"),  linetype = "dashed") +
  geom_hline(aes(yintercept = 8, color = "Parámetros"),  linetype = "dashed") +
  geom_hline(aes(yintercept = mean_speed, color = "Velocidad Promedio")) +
  annotate("text",
           x = as.POSIXct(c("2019-06-24 11:00:00 UTC", "2019-06-24 11:00:00 UTC")),
           y = c(7, 19),
           label = c("Velocidad Mínima Garantizada", "Velocidad Ofrecida"),
           family = "Cloud Calligraphy",
           size=5) +
  geom_label(x = as.POSIXct("2019-08-01 11:00:00 UTC"),
             y = mean_speed,
             label = mean_speed,
             family = "xkcd",
             show.legend = FALSE,
             inherit.aes = FALSE,
             color = "blue")  +
  labs(title = 'VELOCIDADES DE DESCARGA OBSERVADAS',
       subtitle ='ISP: MOVISTAR 20 Mbps', 
       x = 'Fecha',
       y = 'Velocidad (Mbps)',
       color = 'Leyenda:') +
  scale_x_datetime(date_breaks = "5 days",
                   labels = label_date_short(), 
                   expand = expansion(c(0, 0.04))) +
  scale_y_continuous(breaks = seq(0, 22, by = 2), limits = c(0, 23)) +
  scale_colour_manual(values = colors) +
  coord_cartesian(clip = 'off') +
  NULL

Figure 2: Velocidades de Descarga Observadas

faults <- plot_data %>%
  mutate(event_type = ifelse(download <= 8, 'fault', 'normal')) %>% 
  filter(event_type == 'fault') %>% 
  mutate(tbf = as.numeric(as.period(interval(lag(time), time),
                                    unit = 'seconds')) / (3600)) %>% 
  tail(-1)

faults %>% 
  ggplot(aes(x = '', y = tbf)) +
  geom_boxplot(fill = '#FF303094') +
  coord_flip() +
  geom_label(y = median(faults$tbf),
             label = paste(round(median(faults$tbf),1), 'h'),
             family = "xkcd",
             show.legend = FALSE,
             color = "blue") +
  labs(title = 'DIAGRAMA DE CAJA DE TIEMPO ENTRE FALLAS',
       subtitle ='ISP: MOVISTAR 20 Mbps',
       x = '',
       y = 'Horas') +
  NULL

Figure 3: Diagrama de Caja de Tiempo Entre Fallas

Y con la Figura 4 podemos saber cuándo ocurren las horas pico, para saber a qué hora del día es más probable que experimentemos velocidades de Internet lentas.

hour_data <- plot_data %>%
    as_data_frame() %>% 
    mutate(time = format(time, "%H:%M"))

hour_data %>% 
  ggplot(aes(x = time, y = download)) +
  geom_boxplot(fill = "#00B2EE") +
  geom_point(data = hour_data %>% filter(download < 8),
             shape = 1,
             color = "red",
             size = 5) +
  geom_hline(aes(yintercept = 20), color = "orange",  linetype = "dashed") +
  geom_hline(aes(yintercept = 8), color = "orange",  linetype = "dashed") +
  annotate("text",
           x = c("04:00", "04:00"),
           y = c(7, 19),
           label = c("Velocidad Mínima Garantizada", "Velocidad Ofrecida"),
           family = "Cloud Calligraphy",
           size = 5) +
  labs(title = 'DIAGRAMA DE CAJA DE VELOCIDADES DES DESCARGA OBSERVADAS\nPOR HORA DEL DÍA',
       subtitle ='ISP: MOVISTAR 20 Mbps',
       x = 'Hora',
       y = 'Velocidad (Mbps)') +
  scale_y_continuous(breaks = seq(0, 22, by = 2),
                     limits = c(0, 22)) +
  coord_cartesian(clip = 'off') +
  NULL

Figure 4: Diagrama de Caja de Velocidades de Descarga Observadas por Hora del Día

Una vez que tiene datos, las posibilidades de gráficos solo están limitadas por su imaginación, por lo que me detendré aquí, espero que haya disfrutado leyendo este artículo y ahora esté motivado para comenzar a monitorear su propia velocidad de Internet. ¡Que se divierta!, ¡lo veo pronto!.

Acerca de

Sat, 18 Jan 2020 00:00:00 +0000

Andrés Castro Socolich

Hola! mi nombre es Andrés, soy de Arequipa-Perú, soy un Ingeniero Industrial con una especialización en Ciencia de Datos y mi herramienta favorita es R, principalemnte por su comunidad amigable y solidaria, así que he creado este blog para compartir mis proyectos personales de ciencia datos con la comunidad.

Las publicaciones aquí tendrán una amplia variedad de temas, pero todas estarán basadas en datos, así que espero que disfruten leyendo mis publicaciones y las encuentren útiles.