Y es que a veces encontraremos que nuestra aplicación tiene unos requisitos mínimos que el servidor no cumple. Pongamos por ejemplo que queremos instalar prestashop que tiene ciertos requisitos mínimos y que por algún motivo nuestro hosting no satisface.

Cómo configurar variables de PHP desde .htaccess

Hay varias formas de actuar sobre estas variables, pero tal y como reza el título de esta entrada hoy vamos a hacerlo con el archivo .htaccess, y para ello utilizaremos la orden php_value. Su sintaxis es muy sencilla:

php_value + variable_php + valor.

Un ejemplo podría ser que necesitamos que la variable memory_limit esté configurada en 64M y el servidor la tiene configurada en 32M, o quizás el max_input_vars está configurado en 500 y nuestros requisitos mínimos son 1.000. Para ello incluiríamos las siguientes líneas en el archivo .htaccess:

php_value memory_limit 64M
php_value max_input_vars 1000

O supongamos que queremos mostrar los errores de PHP de nuestra aplicación. Podemos hacerlo desde el archivo .htaccess:

php_value error_reporting 7
php_flag display_errors On

Dónde colocar las líneas dentro del archivo .htaccess

Personalmente me gusta colocar este tipo de sentencias al comienzo del archivo .htaccess, justo detrás de los comentarios:

# Comentarios habituales en archivos .htaccess

# variables php
php_value error_reporting 7
php_flag display_errors On

<IfModule mod_rewrite.c>
<IfModule mod_env.c>
SetEnv HTTP_MOD_REWRITE On
</IfModule>

RewriteEngine on
...

Créditos, referencias y artículos relacionados

• Aumentar el límite de memoria de un script en PHP
• Aumentar el limite de tiempo máximo de ejecución de un script en PHP
• Servidor Web en Raspberry PI y Ubuntu Mate
• Como configurar Virtual Hosts en Apache 2 y Ubuntu
• Habilitar módulos en Apache 2 sobre Ubuntu

Así que puestos a escribir sobre habilitar módulos, y dado que es una tarea bastante habitual habitual cuando instalamos un nuevo servidor web, o incluso cuando instalamos algunos paquetes de software sobre un servidor web existente, decidí escribir esta entrada más generalista.

Y es que en la actualidad, en una instalación estándar de Apache 2 sobre Ubuntu 18 se instalan más de 100 módulos, de los cuales sólo hay activos algo más de una veintena.

Habilitar módulos

Lejos quedan los tiempos en los que para habilitar módulos de Apache teníamos que editar el archivo apache.conf, tarea que generalmente no consistía más que en descomentar alguna línea. Hoy basta con ejecutar el comando a2enmod y reiniciar el servidor:

sudo a2enmod modulo
sudo service apache2 restart

Pero descubramos que hay detrás de de este comando.

Los módulos disponibles por Apache 2 se encuentran dentro del directorio /etc/apache2/mods-available/. Lo que quiere decir que si el módulo que queremos habilitar no se encuentra ahí tendremos que copiarlo y asignarle los permisos adecuados.

Por otro lado, los módulos habilitados se encuentran en el directorio /etc/apache2/mods-enabled/. Pero en este caso en lugar de encontrar archivos, encontraremos enlaces simbólicos a los archivos situados en la carpeta /etc/apache2/mods-available/. Así que una alternativa al comando a2enmod es el comando ln:

sudo ln -s /etc/apache2/mods-available/modulo /etc/apache2/mods-enabled/modulo
sudo service apache2 restart

Deshabilitar módulos

Y para deshabilitar módulos la operación es muy similar, con la salvedad de que en lugar de utilizar el comando a2enmod utilizaremos el comando a2dismod:

sudo a2dismod modulo
sudo service apache2 restart

O simplemente eliminaremos el enlace simbólico:

sudo rm /etc/apache2/mods-enabled/modulo
sudo service apache2 restart

Comprobaciones y logs de errores

Podemos saber si un módulo se ha instalado correctamente revisando la salida de la función phpinfo() de php, en la sección apache2handler.

Y en caso de experimentar cualquier tipo de problema, el primer lugar dónde consultar qué está ocurriendo son los logs de error de Apache 2, en el archivo /var/log/apache2/error.log.

cat /var/log/apache2/error.log

Créditos, referencias y artículos relacionados

• Imagen de portada por Wichan Yodsawai.
• Servidor Web en Raspberry PI y Ubuntu Mate.
• Como configurar Virtual Hosts en Apache 2 y Ubuntu.
• Archivos y permisos de usuario en Apache 2 y Linux.

Además de la versión de Linux que tenemos instalada, existen otros aspectos relativos al sistema que guardan bastante relación cómo son la distribución, si es un sistema de 32 o de 64 bits o la versión del kernel. Estos datos son un buen complemento y pueden resultar de gran ayuda cuando buscamos la versión de Linux.

Versión de Linux desde el terminal

La forma más rápida y sencilla de averiguar sobre que versión de Linux estamos trabajando es mediante el terminal, desde dónde tendremos múltiples opciones.

Comando lsb_release

Es mi opción más habitual. Lsb son las siglas de Linux Standard Base, un dato que quizás como a mi te ayude a recordar mejor este comando:

lsb_release -a

Y nos devolverá un resultado similar al siguiente, dónde además de la versión podemos ver la distro:

Distributor ID: Ubuntu
Description:    Ubuntu 16.04.6 LTS
Release:        16.04
Codename:       xenial

En caso de que el comando no te funcione, es decir, que no esté instalado por defecto, solo tendremos que instalarlo:

sudo apt-get update
sudo apt-get install lsb-release

Comando hostnamectl

Otra alternativa quizás menos específica pero que igualmente arrojará la información que buscamos es el comando hostnamectl. Este comando además nos devolverá información sobre la distribución, la versión del kernel, la arquitectura del procesador o la ID de la máquina:

hostnametcl

En este caso el resultado seria algo así:

   Static hostname: pcname
         Icon name: computer
        Machine ID: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
           Boot ID: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  Operating System: Ubuntu 16.04.6 LTS
            Kernel: Linux 4.4.38-v7+
      Architecture: arm

/etc/*-release

Otra alternativa aparentemente menos sofisticada pero igualmente válida es consultar la información de los archivos /etc/os-release, /etc/lsb-release o /etc/*-release. En función de nuestra distro la información se encontrará en uno o varios de estos archivos.

cat /etc/os-release

Las salidas que obtendremos pueden variar ligeramente, pero básicamente serán parecidas a la que muestro. En esta ocasión también vemos que obtenemos el nombre de la distribución.

NAME="Ubuntu"
VERSION="16.04.6 LTS (Xenial Xerus)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 16.04.6 LTS"
VERSION_ID="16.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
VERSION_CODENAME=xenial
UBUNTU_CODENAME=xenial

Versión de Linux desde el escritorio

Desde el escritorio la cantidad de opciones se reduce, o no, pues mi recomendación, si sólo queremos conocer la versión de Linux sobre la que estamos trabajando es que presiones la combinación de teclas:

Ctrl + Alt + t

Y una vez que se abra el terminal uses una de las opciones que acabamos de ver.

Hardinfo

Una alternativa sencilla y lijera para ver información sobre la versión de Linux desde el entorno gráfico es utilizar el programa Hardinfo. Es muy probable que no esté instalado por defecto, si así, como es habitual:

sudo apt-get update
sudo apt-get install hardinfo

La aplicación es muy sencilla de utilizar y solo deberemos desplazarnos hasta el apartado «Sistema Operativo». Como veis en la captura de pantalla, la aplicación tiene mucha información extra de gran utilidad:

Otra información Interesante

Como comentamos al comienzo de la entrada existe cierta información que guarda mucha relación con la versión de Linux y que puede sernos muy útil. Veamos cómo obtener alguna de esta información.

Averiguar si una instalación de Linux es de 32 o de 64 bits

Es más que probable que en ciertas ocasiones quieras saber si tu instalación de Linux es de 32 o de 64 bits. Podemos averiguarlo utilizando alguno de los siguientes comandos:

getconf LONG_BIT

O:

uname -i

Averiguar la versión del kernel de Linux

Esta es otra duda muy relacionada que con el paso del tiempo y la sofisticación de Linux se ha vuelto algo menos común. De nuevo hacemos uso del comando uname:

uname -r

Y la salida que nos devolverá será algo así:

4.15.0-51-generic

Créditos y referencias

• Imagen de portada: Arek Socha

Esta mañana mi equipo me ha redirigido en varias ocasiones a páginas de dudosa reputación, abriendo varios pop ups. Tras algunas pruebas pude comprobar que el problema se encontraba en este blog y no en mi equipo, así que si se te ha abierto algún pop up redirigiendote a una otra página no deseada te pido disculpas.

En el caso de que tú también te hayas visto afectado por este problema, o por otro similar, te indico los pasos a seguir para solucionarlo. Los pasos 4, 5 y 6 son específicos para este caso:

1. Haz una copia de seguridad de tu site, tanto de los archivos como de la base de datos.
2. Identifica el plugin problemático. La forma más sencilla es desactivarlos todos e ir activando poco a poco.
3. Una vez detectado que plugin era el causante del problema elimínanalo.
4. Elimina el archivo /wp-content/wp-cache-config.php.
5. Elimina el usuario que ha creado el plugin, en mi caso se llamaba wp_update.
6. Elimina todos los registros de la tabla wp-option dónde en el campo option_name aparezca el texto «yuzo». Si tienes más plugins de este fabricante tendrás que ser más selectivo
7. Cambiar la clave de la base de datos y actualiza los datos del archivo de configuración wp-config.php para que tu WordPress siga funcionando.
8. Cambia la clave de todos los usuarios de wordpress.
9. Cambia la clave del ftp.
10. Descarga una versión de wordpress limpia y reemplaza los archivos en las carpetas /wp-admin y wp-includes. Para ello debes tener en cuenta:
    1. Si has realizado algún cambio en esas carpetas lo perderás.
    2. Asegurate que la versión sea exactamente la misma.

No soy experto en wordpress ni en seguridad, estas recomendaciones son fruto de algo de lectura al respecto y de mi experiencia, y no puedo asegurarte que en tu caso funcionará, pero por eso mismo el primer paso es un backup. Si tienes conocimiento de algún otro paso necesario a seguir agradecería tu colaboración para compartirlo.

Esta entrada está pensada para ser una guía de consulta dónde encontrar un resumen de los que a mi modo de ver son los principales comandos. Vim tiene muchísimas opciones, así que evitaremos entrar en las más complejas y en las menos prácticas, así como en el modo visual. De cualquier modo esta información es más que suficiente para hacer un uso habitual y fluido de Vim.

Para profundizar más te recomiendo consultar el manual, dónde encontrarás la información al completo, las posibilidades de Vim son muchísimas.

Convenciones de este documento

En este documento utilizaremos las siguientes convenciones:

• [x] Modificador entre paréntesis. Es un modificador de comando opcional.
• {x} Modificador entre corchetes. Es un modificador de comando obligatorio.
• rango. Especificaremos un rango definiendo el valor inicial y el final separados por una coma. Por ejemplo: 2,5.

Comando de ayuda

La mejor forma de complementar y ampliar esta guía es usar el comando de ayuda:

El manual se visualizará en el propio VIM se comporta como cualquier otro documento que abramos en este editor, y por lo tanto serán efectivos todos los comandos que indicamos en este documento con la excepción de que no permite guardar. Así que para salir y regresar al documento dónde nos encontrábamos antes de consultar el manual escribiremos el comando :q!.

Comandos de desplazamiento

Comandos de inserción de texto

Comandos de eliminación de texto

Comandos para reemplazar texto

Comandos para deshacer y rehacer cambios

Comandos para buscar textos

Comandos para guardar y salir

Conclusión

Para los que vienen de un entorno gráfico el primer contacto con Vim puede ser algo inesperado y quizás chocante. De cualquier forma la curva de aprendizaje de Vim es bastante sencilla y cuando aprendemos su dinámica y unos pocos comandos ya nos manejamos con una soltura difícil de imaginar al principio. Hoy hemos visto una lista de los comandos que he considerado más prácticos, ¿cuáles usas tú?, ¿crees que falta alguno?, ¿echas en falta algo?

Avahi

La mala noticia es que para lograr acceder por nombre a máquinas Linux en una red local con garantías la mejor solución es disponer de un servidor DNS (Bind es la opción Open Source más extendida), y en esta entrada no hablaremos sobre servidores DNS.

En esta entrada utilizaremos Avahi, una implementación gratuita de Zero-Configuration Networking que permite difundir y descubrir servicios y equipos en una red local. Quizás a alguno le resulte más familiar si citamos a Bonjour, que es la implementación propietaria que tiene Apple de esta tecnología.

Y en función de nuestras necesidades es posible que Avahi nos sirva o no (lógico). El principal motivo es que no basta con instalarlo en la máquina a la que queremos acceder por nombre (llamémosla máquina Destino), sino que cada equipo que quiera acceder por nombre a la máquina Destino debe poder trabajar con la tecnología Zero-Configuration Networking para interpretar la información publicada por nuestra máquina Destino.

Máquinas Destino y Clientes

Pongámonos en situación, de un lado tenemos una máquina corriendo Ubuntu, en mi caso es una Raspberry Pi corriendo la versión 16.0.4.2 de Ubuntu Mate. El hostname de esta máquina es «maquina1», su ip 192.168.1.15 y para agilizar la lectura, como ya hemos dicho, la llamaremos máquina «Destino». En esta máquina hemos instalado un servidor web y queremos acceder a ella mediante hostname.

Del otro lado tenemos una serie de equipos con distintos SSOO que son los que quieren consumir el servicio web accediendo por nombre. A estas máquinas las llamaremos «Clientes» y vamos a suponer que tenemos:

1. Cliente Linux, corriendo Ubuntu 18.
2. Cliente Windows, corriendo Windows 10.
3. Cliente Android, corriendo Android Oreo 8.1.

Lo siento por los amantes de Apple pero no tengo ningún dispositivo de la manzanita para probar, aún así si eres uno de ellos sigue leyendo porque estoy convencido que te será de utilidad.

Instalar y configurar Avahi

Comenzaremos realizando las instalaciones necesarias en la máquina Destino. En función de vuestra distro es posible que todos o algunos de estos paquetes ya estén instalados.

sudo apt-get update
sudo apt-get install avahi-daemon
sudo apt-get install avahi-utils
sudo apt-get install libnss-mdns

Y acto seguido editaremos la configuración de Avahi. Es buena idea que antes de editar cualquier archivo de configuración guardéis una copia que os ayude a volver al punto inicial si fuera necesario, aunque vamos a tocar muy poca configuración.

suco cp /ect/avahi/avahi-daemon.conf /etc/avahi/avahi-daemon.conf.bck
sudo vim /etc/avahi/avahi-daemon.conf

En el archivo de configuración nos centraremos primero en el nombre de la máquina y el dominio. Mi recomendación es que mantengáis la configuración por defecto, es decir ser coherentes y que el host-name coincida con el de la propia máquina y que el dominio sea «local». De esta forma accederemos a la máquina con maquina1.local.

[server]
host-name=maquina1
domain-name=local

Nos aseguraremos también de que las siguientes opciones se encuentren como mostramos:

[publish]
disable-publishing=no
disable-user-service-publishing=no
publish-addresses=yes

Reiniciamos el servicio y lo agregamos al arranque de nuestra máquina:

sudo service avahi-daemon restart
sudo update-rc.d avahi-daemon defaults

Y con esto hemos terminado con la máquina Destino.

Maquinas Clientes

Como ya mencionamos cada máquina cliente debe ser capaz de trabajar con la tecnología Zero-Configuration Networking para poder alcanzar la máquina Destino por nombre, así que veamos caso a caso.

Desde Linux

En cada equipo con sistema operativo Linux con el que queramos acceder por nombre a la máquina Destino deberemos instalar Avahi. Así que no tenemos más que repetir las instrucciones definidas en el apartado «Instalar y Configurar Avahi».

Desde Windows

Por defecto Windows no nos dejará acceder por hostname y por ahora no existe implementación de Avahi para este sistema operativo. En su defecto podemos instalar el programa «Servicios de impresión Bonjour para Windows», de Apple, que aunque está pensado para otro uso nos permitirá cubrir nuestra necesidad y alcanzar la máquina Destino por nombre.

Desde Android

Lamentablemente no he encontrado ninguna aplicación o demonio para Android que permita que cualquier aplicación que corra en este sistema operativo sea capaz de acceder por nombre a nuestra máquina Destino, una lástima. Si conoces alguna solución para ello estaría muy agradecido de que la compartas en un comentario.

IOS y MacOSX

Como he dicho no tengo ningún dispositivo de Apple para realizar pruebas, pero conociendo que tienen su propia implementación de de Zero-Configuration Networking (Bonjour), me atrevería a decir que podremos acceder por nombre a nuestra máquina Destino sin necesidad de instalar ningún software adicional.

Comprobar el funcionamiento

Aunque es de primero de pre-escolar (creo que ahora lo llaman infantil), me gusta comprobar las cosas, y la forma más sencilla de hacerlo es utilizar el comando ping. Si lo hemos conseguido obtendremos algo así:

ping raspi.local
PING raspi.local (192.168..15) 56(84) bytes of data.
64 bytes from 192.168.1.15 (192.168.1.15): icmp_seq=1 ttl=64 time=6.68 ms
64 bytes from 192.168.1.15 (192.168.1.15): icmp_seq=2 ttl=64 time=4.61 ms

Y si algo no funciona como esperamos obtendremos algo así:

ping maquina1.local
ping: maquina1.local: Nombre o servicio desconocido

Y como dijimos que en la máquina Destino teníamos un servidor web, al escribir maquina1.local en la barra de direcciones del navegador, obviamente, accederemos al contenido publicado.

Conclusión

Con Avahi podemos acceder por nombre a máquinas con sistema operativo Linux en nuestra red local. Su mayor limitación es que nos veremos obligado a que tanto la máquina a la que queremos acceder, como las máquinas con las que queremos acceder deben tener instalada una implementación de Zero-Configuration Networking.

Así que si bien resuelve ciertas situaciones y necesidades, si pensamos en una red de varias decenas de equipos con distintos sistemas operativos existen otras alternativas más escalables.

Como siempre me gustaría saber cómo cual es tu experiencia, ¿has usado Avahi? ¿accedes por ip? ¿utilizas otra tecnología u otros programas? Deja un comentario y danos tu opinión.

Por otro lado, en función de diferentes factores relacionados con un proyecto de desarrollo podemos trabajar en equipo, que es lo más probable, o solos. Cuando trabajamos en equipo es lógico que el software de control de versiones se encuentre en un servidor centralizado. Cuando trabajamos solos podemos decidir que solo esté en nuestra máquina.

Personalmente incluso trabajando en solitario en un proyecto me gusta versionar contra en un servidor centralizado por dos motivos principales:

1. Mayor seguridad ante una eventualidad en mi equipo local, circunstancia que no evita que el proyecto deba estar respaldado por copias de seguridad.
2. Posibilidad de trabajar en múltiples dispositivos, una opción más o menos interesante en función de nuestras circunstancias.

En caso de que el proyecto que tengamos entre manos sea de ámbito personal, es más que razonable pensar que no todos disponemos de un servidor en casa dónce centralizar el versionado. Esta situación la podemos resolver con un viejo pc, o si no disponemos de uno con una Raspberry Pi que haga las veces de servidor. Aquí te dejo un enlace al artículo Instalar y configurar Git en una Raspberry PI con Ubuntu Mate, por si quieres probarlo.

Así que vamos al lío y para ello asumiremos que nuestro servidor está configurado con la ip 192.168.1.10 y el nombre de nuestro usuario es usuario.

Creamos nuestro repositorio remoto

Lo primero que debemos hacer es crear y configurar correctamente un repositorio vacío en la máquina remota, así que empezaremos por conectarnos a ella:

ssh usuario@192.168.1.10

Ya en la consola remota creamos el directorio dónde alojaremos el repositorio que vamos a crear, personalmente creo un directorio en el que incluyo todos los repositorios:

cd ~
mkdir gitRepositoryRoot
cd gitRepositoryRoot
mkdir nuevoProyecto
cd nuevoProyecto

Y por fin creamos nuestro repositorio vacío y lo configuramos:

git --bare init
git config core.sharedrepository 1
git config receive.denyNonFastforwards true
git config --bool core.bare true

El último paso en la máquina remota es asignar los permisos adecuados al repositorio:

find objects -type d -exec chmod 02770 {} \;

Creamos nuestro repositorio local

Una vez que nuestro repositorio está correctamente creado en el servidor deberemos crear un repositorio local a partir de los fuentes que ya tenemos para posteriormente enlazarlo y enviarlo al repositorio que previamente hemos creado en la máquina remota.

Creamos el repositorio local y añadimos los fuentes existentes que supondremos que se encuentran en /var/www/nuevoProyecto:

cd /var/www/nuevoProyecto
git init
git add *
git commit -m "Commit inicial"

Creamos el repositorio y añadimos los fuentes:

git remote add origin ssh://usuario@192.168.1.10/home/usuario/gitRepositoryRoot/nuevoProyecto
git push -u origin master

Comprobamos que todo ha salido bien

Por último comprobaremos que hemos realizado el proceso correctamente y todo funciona correctamente.

git checkout origin/master
git branch -f master origin/master
git checkout master

Conclusión

Trabajemos en grupo o en solitario versionar nuestro código en una máquina remota es una tarea sencilla que aporta grandes beneficios. Cómo siempre me gustaría saber cómo lo haces tú, qué haces distinto, si este artículo te ha ayudado… Si te animas a compartir deja un comentario.

Para este artículo asumiremos que disponemos de varios host virtuales y que vamos a asignar los permisos adecuados solo a uno de ellos. La carpeta raíz es /var/www/html y la pública /var/www/html/public.

En caso de que tengas un servidor Apache 2 recién instalado lo habitual es que las carpetas mencionadas en el párrafo anterior sean /var/www y /var/www/public respectivamente.

Por último antes de entrar en materia indicar que también asumiremos que el usuario con el que trabajamos es «usuario».

Asignamos los permisos

Comenzaremos asegurándonos de que /var/www/html pertenezca al grupo www-data:

sudo chgrp www-data /var/www/html

Nos aseguramos también que nuestro usuario pertenezca al mismo grupo:

sudo usermod -a -G www-data usuario

Asignamos los permisos adecuados:

sudo chmod -R 775 /var/www/html
sudo chmod -R g+s /var/www/html

Y por último nos aseguramos de ser los propietarios del directorio:

sudo chown -R usuario /var/www/html

En este punto ya tenemos los permisos de usuario correctamente configurados, pero como siempre es bueno comprobarlo.

Comprobamos que todo sea correcto

Para comprobar que todo haya salidos bien accedemos a /var/www y listamos los archivos con detalle:

ls -l

Deberíamos tener algo similar a lo siguiente:

total 2
drwxrwxr-x 4 usuario www-data 4096 dic 19 18:01 html
drwxrwxr-x 8 usuario www-data 4096 dic 19 18:07 vhost1

Los archivos y/o carpetas de este directorio pueden cambiar en función de lo que tengas en /var/www, pero al margen de eso podemos ver que tanto el usuario, el grupo y los perisos son correctos.

Si entramos dentro de /var/www/html y hacemos lo mismo el resultado debe ser similar.

Conclusión

Una tarea sencilla y rápida que nos ahorrará posibles complicaciones futuras. Y como siempre me gusta saber tu opinión, ¿qué haces distinto al establecer los permisos? ¿Te ha servido  este artículo para solucionar algún problema de permisos? ¿Cuál es tu experiencia en este tema?

Créditos, referencias y artículos relacionados

• Como configurar Virtual Hosts en Apache 2 y Ubuntu
• Servidor web en Raspberry Pi y Ubuntu Mate
• Debugar PHP con NetBeans y XCode

De esta forma podremos dejar nuestro Raspberry en algun lugar de casa que no moleste con solo un adaptador de corriente, y si nos venimos arriba además con un cable de red.

Así que vamos al lío y veamos varias formas para hacer esto:

Configurar SSH en Raspbian desde la interface gráfica

Esta es quizás la forma más habitual de hacerlo, principalmente por comodidad. Desde la interface gráfica accedemos a Menu -> Preferences -> Raspberry Pi Configuracion. Se levanta la aplicación Raspberry Pi Configuration, que tiene el siguiente aspecto (ojo que en el pantallazo que muestro ya he cambiado de pestaña):

Y una vez abierta la aplicación:

1. Nos situamos en la pestaña Interfaces.
2. Activamos el SSH.
3. Guardamos con el botón OK.

Configurar SSH en Raspbian desde la consola

Si nos hemos decidido por un Raspbian sin entorno de escritorio o si simplemente preferimos trabajar con la consola,  ejecutamos el siguiente comando:

sudo raspi-config

Esto abrirá la aplicación que tiene el siguiente aspecto:

A partir de aquí deberemos seguir los siguientes pasos:

1. Seleccionamos Advanced Options.
2. Navegamos hasta la opción SSH.
3. Acitvamos el servidor.
4. Guardamos y salimos con la opción Finish.

Activar SSH en Ubuntu Mate desde la consola

En Ubuntu Mate también es muy sencillo activar el acceso SSH, por defecto y al igual que en Raspbian viene instalado, así que solo tendremos que habilitarlo mediante las siguientes instrucciones en la consola:

sudo systemctl enable ssh
sudo systemctl start ssh

Conclusión

El acceso mediante SSH es de gran utilidad para conectar remotamente a nuestra Raspberry. Además, es sumamente sencillo configurar el servidor SSH tanto en Raspbian como en Ubuntu Mate, de hecho es tan habitual que ni si quiera tendremos que instalarlo pues estas dos distribuciones ya lo traen instalado por defecto.

Por otro lado, es increíble la cantidad de desarrolladores para los que si bien en otros lenguajes utilizar un programa para debugar forma parte de su día a día, cuando programan en php lo hacen de una forma un tanto rudimentaria valiéndose de funciones cómo echo(), print_f(), die()  u otras que les ayuden a mostrar en el navegador lo que deberían ver en la herramienta de debug.

Lo reconozco, yo también lo he hecho durante largos periodos de tiempo, y por ese motivo conozco de primera mano la gran diferencia que existe entre utilizar una herramienta adecuada o no hacerlo. Lo peor de todo es que solucionar esta situación es muy sencillo, y basta con un poco de disciplina y 15 minutos de configuración.

Aprovechando que tengo un entorno de desarrollo relativamente nuevo, vamos a ver como se configura. El software que utilizo es:

• Ubuntu 18.04.1 LTS
• Apache 2.4.29
• PHP 7.2.10
• NetBeans 8.2
• Mozilla Firefox

Vamos a dar por hecho que ya tenemos este software instalado y nos centraremos en instalar y configurar XDebug.

Configuración del servidor

El primer paso es comprobar si tenemos XDebug instalado, por defecto no suele ser así. Esta comprobación la podemos hacer mediante phpinfo(). Si no está instalado lo instalamos:

sudo apt-get install php-xdebug

Buscamos el archivo de configuración de la extensión, en mi caso /etc/php/7.2/apache2/conf.d/20-xdebug.ini. Lo editamos:

sudo vim /etc/php/7.2/apache2/conf.d/20-xdebug.ini

El archivo debería quedar así:

zend_extension=xdebug.so
xdebug.profiler_enable = On
xdebug.remote_enable=On
xdebug.remote_host="localhost"
xdebug.remote_port=9000
xdebug.remote_handler="dbgp"

La primera línea que habilita la extensión de php ya deberíais tenerla, así que solo tendríamos que agregar el resto. Prestad especial atención al puerto, pues tendrá que coincidir con el que especifiquemos en NetBeans.

Ya sólo nos queda reiniciar Apache y pasaremos a configurar NetBeans:

sudo service apache2 restart

Configuración de NetBeans

Ya casi estamos. Abrimos la configuración de NetBeans mediante los menús «Tools» -> «Options». Accedemos a la configuración de PHP y en la pestaña «Debugging» nos aseguramos de que hemos especifiaco el mismo puerto que en la configuración de XDebug para PHP, en nuestro caso el puerto 9000.

Guardamos la configuración, salimos y con esto ya tenemos toda la configuración relativa a XDebug hecha.

La última configuración necesaria para poder debugar se realiza en la configuración de cada proyecto de Netbeans. Para acceder a ella debemos tener visible la ventana de proyectos, botón derecho sobre el propio proyecto y seleccionamos la opción «Properties»del menú.

En la venta de configuración, accederemos al menú «Run Configuration» y nos aseguraremos que los campos «Project URL» y «Index File» están correctamente configurados.

Conclusión

Una configuración muy sencilla que nos ahorrará muchos quebraderos de cabeza. ¿Y tú cómo debugas cuando programas en PHP?