miércoles, 13 de julio de 2016

Como crear un servidor web en la red local accesible desde Internet

Hace demasiado tiempo que no escribo nada. Tengo miles de excusas (todas ciertas), pero el caso es que todas ellas se resumen en una: demasiado trabajo. Hoy voy a intentar escribir un artículo sobre como crear un servidor web en la red local accesible desde Internet con Apache2.

Con la mejora de las conexiones que están ofreciendo los operadores de telefonía en los últimos tiempos (banda ancha, fibra óptica, 100/10 MB, 300/30 MB, 300 MB simétricos, ...), cualquiera puede plantearse crear sus propios servicios web sin contratar ningún tipo de hosting. Es decir a coste cero. Bueno cero no porque siempre tendrás que pagar la conexión, pero eso lo ibas a pagar igual, ¿no?

Prerequisitos

Lo primero y más importante es disponer de conexión a Internet de banda ancha en casa. Idealmente fibra óptica simétrica. También es indispensable tener un PC que pueda estar conectado a la red todo el día. El tipo de PC es irrelevante, pero lo idóneo sería que tuviera un sistema operativo de tipo GNU/Linux. Por supuesto todo lo que voy a explicar se puede hacer con Windows, pero a partir de aquí usaré ejemplos para Ubuntu 14.04 que es una distribución de Linux muy popular. También sería muy interesante disponer de una IP estática, aunque no es obligatorio.

Instalar el software requerido

  • Apache2: Es el servidor HTTP más usado en el mundo. Es un programa de código abierto, multiplatafortma (Linux, Macintosh, Windows, ...), que implementa el protocolo HTTP/1.12. Es altamente configurable y permite utilizar multitud de módulos que añaden capacidades al servidor: SSL, Rewrite, PHP, Python, Perl, ...
    $ sudo apt-get install apache2
    $ apache2 -v
    
  • PHP, Python, Perl u otro lenguaje de programación similar. Yo opto por PHP que es muy fácil de usar y muy rápido de aprender, pero cualquier otro es válido. Para usar otros lenguajes como Java se necesitan herramientas diferentes.
    $ sudo apt-get install php5 libapache2-mod-php5
    $ php5 -v
    
  • Una base de datos como MySQL siempre es recomendable, aunque no obligatoria. Depende de los servicios que quieras ofrecer será imprescindible.
    $ sudo apt-get install mysql-server mysql-client php5-mysql
    $ mysql -V
    

Programar el sitio web

Para este paso se necesitan conocimientos de programación. En cualquier caso vamos a crear un sencillo "Hola Mundo" en PHP. Lo primero es editar un fichero de texto en la siguiente ruta:

$ cd /var/www/html/
$ mkdir hello-world
$ cd hello-world
$ gedit index.php

...y escribir el siguiente contenido:

<?php
echo "Hello World!";

Para ver que todo funciona correctamente hay que abrir un navegador e introducir la ruta: http://localhost/hello-world/index.php

Si todo ha ido bien veremos nuestro Hola Mundo en la pantalla del navegador. Si no funciona probablemente haya algún problema con Apache2. Por ejemplo que no se haya iniciado correctamente el servicio:

$ sudo service apache2 start

Acceso desde la red local

En este momento, si tienes otro dispositivo conectado a la misma red local (da igual si es un ordenador, un móvil o un tablet, si es por cable o por wifi), podrás acceder al servidor web del primero usando tu navegador favorito, poniendo la dirección IP del ordenador al que hemos instalado Apache2. Para ello lo primero es averiguar la dirección IP privada del ordenador con el servidor web. Podemos escribir ifconfig en el terminal, pero como sale mucha más información, también podemos usar comandos más complejos, pero que obtienen exactamente la información que necesitamos: La dirección IP:

$ ip route get 8.8.8.8 | head -1 | cut -d' ' -f8
192.168.1.38

En este caso la dirección IP de nuestro servidor es 192.168.1.38. Ojo que esa dirección puede cambiar cada ver que se reinicia el router. Entonces escribimos la siguiente ruta en otro dispositivo (PC, tablet o móvil): http://192.168.1.38/hello-world/index.php

Podría darse el caso de que Apache2 estuviera configurado para rechazar las conexiones desde fuera del localhost. En ese caso obtendríamos un mensaje como el siguiente:

Las causas de ese problema pueden ser muy diversas dependiendo de la versión de Apache2 y proponer soluciones a este problema se escapa del propósito de este artículo. En cualquier caso siempre se le puede preguntar a Google. La solución probablemente pase por editar el archivo /etc/apache2/apache2.conf y eliminar las restricciones de acceso, dejando algo similar a lo siguiente:

<Directory /var/www/>
    AllowOverride None
    Require all granted
</Directory>

Acceso desde Internet

Para acceder a Internet el router usa una IP pública, la misma para toda la red local. Eso quiere decir que todos los dispositivos conectados a la red local usan la misma dirección IP para conectarse a Internet, ya que todos tienen la misma dirección IP pública. Entonces, ¿Como podemos acceder desde el exterior a nuestro servidor web si varios dispositivos comparten la misma IP? La respuesta es que hay que configurar los puertos de red en el router. Es lo que se conoce como abrir puertos.

Apache2 usa por defecto el puerto 80 para el protocolo HTTP, entonces lo que habría que hacer es decirle al router que todas las conexiones que lleguen por el puerto 80 nos las redireccione a la máquina donde tenemos el servidor web que, recordemos, es la 192.168.1.38.

Para poder acceder desde Internet a nuestro servidor web es necesario conocer nuestra IP pública. No la privada que usa nuestro equipo dentro de la red local, sino la pública que es la que usa nuestro router para acceder a Internet y que puede ser fija (siempre la misma) o variable (distinta cada vez que se reinicia el router). Para averiguar nuestra IP pública podemos ir a cualesmiip.com y consultarlo o bien podemos escribir la siguiente instrucción en el terminal:

$ curl ifconfig.me
88.20.46.249

Nuestro servidor web ya es accesible desde Internet pero aun hay varios temas que solucionar:

  1. Cada vez que se reinicie el router la IP privada asignada a nuestro servidor puede cambiar, con lo que éste dejará de ser accesible desde Internet ya que nuestro router seguirá redireccionando las peticiones que lleguen por el puerto 80 a la IP 192.168.1.38 pero a lo mejor ahora nuestro servidor tiene otro. Lo que vamos a hacer es poner una IP privada fija a nuestro servidor.
  2. En segundo lugar abrir el puerto 80 no es lo más inteligente a no ser que queramos hacer una web abierta a todo el mundo. Lo mejor es usar un puerto diferente, dejando el puerto 80 cerrado.
  3. Por último la IP pública de nuestro router también podría cambiar cada vez que se reinicie por lo que no sabríamos que IP poner en el navegador. La única solución a esto es contratar una IP pública estática a nuestro proveedor de Internet.

Asignar una IP privada fija a nuestro servidor web

El router utiliza el protocolo DHCP para asignar las direcciones IP privadas a los distintos dispositivos conectados a la red local. De esta forma cada dispositivo tendrá un IP diferente cada vez que se reinicie el router. Sin embargo es posible asignar de forma sencilla una dirección IP fija (siempre la misma) a un dispositivo determinado. Por desgracia cada dispositivo y cada router tiene su forma particular de hacerlo. Mirando en la configuración de mi router he visto que las direcciones que asigna DHCP para la mi red local son de tipo 192.168.1.x, donde x > 32. Si x=1 es la dirección del router (default gateway), eso quiere decir que tengo libres las direcciones de la 2 <= x <= 32. Yo he elegido la IP 192.168.1.16 sin un motivo concreto.

Para asignar una IP fija en Ubuntu hay que ir a la Configuración del Sistema >>> Red >>> Cableada o Inalámbrica (depende) >>> Opciones... >>> Ajustes IPv4, seleccionar Método manual y rellenar los campos como en la imagen.

Cambiar el puerto de nuestro servicio web

Como hemos dicho el protocolo HTTP suele usar el puerto 80, pero si sólo queremos acceder nosotros a nuestro servicio web podemos configurar Apache2 para que use cualquier puerto en el rango 1-65535. Algunos puertos son usados por otros servicios, como por ejemplo:

  • 20=FTP-data
  • 21=FTP-control
  • 22=SSH
  • 23=Telnet
  • 25=SMTP
  • 80=HTTP
  • 110=POP3
  • 143=IMAP
  • 443=HTTPS-SSL
  • 465=SMTP-SSL
  • 993=IMAP-SSL
  • 995=POP3-SSL
  • 3306=MySQL
  • 8080=Alt-HTTP
  • Ver lista completa

En principio podemos usar cualquier puerto libre. Por ejemplo podemos usar el puerto 8010. Para ello hay que seguir varios pasos:

  1. Decir a Apache2 que tiene que escuchar el puerto 8010. Para ello, editar el archivo /etc/apache2/ports.conf y añadir la línea Listen 8010:
    $ sudo gedit /etc/apache2/ports.conf
    
    Listen 80
    Listen 8010
    <IfModule ssl_module>
        Listen 443
    </IfModule>
    <IfModule mod_gnutls.c>
        Listen 443
    </IfModule>
    
  2. Añadir un virtual host que escuche el puerto 8010. Para ello crear el archivo /etc/apache2/sites-available/001-my-web-server.conf:
    $ sudo gedit /etc/apache2/sites-available/001-my-web-server.conf
    
    <VirtualHost *:8010>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html/hello-world
        ErrorLog ${APACHE_LOG_DIR}/error-simple-proxy.log
        CustomLog ${APACHE_LOG_DIR}/access-simple-proxy.log combined
        DirectoryIndex index.php index.html index.htm index.cgi
    </VirtualHost>
    
  3. Activar el nuevo virtual host:
    $ cd /etc/apache2/sites-enabled/
    $ sudo ln -s ../sites-available/001-my-web-server.conf
    
  4. Reiniciar el servicio de Apache2:
    $ sudo service apache2 restart
    

miércoles, 24 de febrero de 2016

Introducción a Git

Pongo a continuación una presentación sobre Git, el sistema de control de versiones, y las diferencias con Subversion. Hice esta presentación como soporte a un workshop sobre Git en mi trabajo actual.

jueves, 21 de enero de 2016

Clasificación de lenguajes de programación en 2015

Infographic in DZone.com

Según Dzone.com:

  1. Javascript
  2. Java
  3. Python
  4. PHP
  5. C
  6. C++
  7. Ruby
  8. C#
  9. Objective-C
  10. Perl
  11. Css 3
  12. SQL
  13. Bash
  14. R
  15. Scala
  16. Matlab
  17. Visual Basic
  18. Haskell
  19. Go
  20. .Net
  21. Swift
  22. Clojure
  23. Groovy

domingo, 3 de enero de 2016

Menú de inicio desaparecido en Windows 10

Vamos con la primera entrada del año.

No acostumbro a usar sistemas Windows pero tengo un PC con Windows 10 para juegos1, para hacer pruebas y porque siempre conviene saber como va todo. Como decía, suelo usar ese PC para jugar por lo que es una máquina potente (Core i7, 16 GB de RAM, GTX 750 Ti, etc.), lo convierte en ideal para probar diferentes distribuciones de Linux en máquina virtual. Así que estaba yo el otro día tratando de instalar Xubuntu 15.10 en VirtualBox cuando sin saber bien como me cargué el menú de inicio, la barra de tareas y buena parte de la aplicaciones de Windows 10.

El escritorio funcionaba perfectamente, pero no podía acceder al menú de inicio, no aparecían los programas abiertos en la barra de tareas, el reloj y los iconos de la barra de estado habían desaparecido y los programas nuevos tampoco funcionaban (configuración del sistema, visor de fotos, etc.). En cambio podía ejecutar sin problema Firefox o Chrome e incluso el propio Virtual Box. También funcionaban los juegos (por ejemplo World of Warcraft). Reiniciar el sistema no sirvió para nada así que me puse a investigar.

Buscando buscando he encontrado que es un problema bastante común que lleva ocurriendo desde las primeras versiones preview de Windows 10. Hay varios artículos que tratan del tema como este, este, este, este o este, pero ninguna de las soluciones propuestas parecían funcionar.

Al final encontré el artículo Has your Windows 10 Start menu stopped working? Here are four ways to fix it que es una recopilación de todas las técnicas que puedes aplicar para solucionar el problema de menos agresiva a más agresiva. Al final lo que me funcionó a mi fue crear un nuevo usuario desde el Poweshell, reiniciar el PC y entrar con el nuevo usuario, pero ya llevaba probadas unas cuantas cosas por lo que bien pudo ser una combinación de factores.

Notas

[1] La principal función de ese PC es jugar y tiene Windows porque, reconozcámoslo, en Linux jugar es difícil. Steam es un gran avance pero configurar correctamente los drivers de la tarjeta gráfica es misión imposible. Ni los controladores libres ni los privativos funcionan como lo hacen en Windows. Y eso suponiendo que existan controladores para tu tarjeta gráfica.

viernes, 11 de diciembre de 2015

PHP 7.0.0 liberado

Acaba de hacerse oficial el lanzamiento de PHP 7.0.0. La nueva versión del lenguaje incluye numerosas mejoras y sobre todo un aumento de rendimiento considerable. Algunas de las nuevas características de PHP 7 son:

  • Tipo de retorno en las funciones: Por fin se podrá declarar que devuelve una función o método. Esta es una característica que siempre he echado en falta en PHP. Sobre todo cuando se diseñan interfaces o clases abstractas, poder indicar que debe devolver un método es algo muy útil. Ejemplos.
  • Declaración de tipos escalares: Se trata de poder definit el tipo de una variable para int, float, string y bool. Esto es útil por ejemplo para definir los parámetros de una función o método. También se definen dos niveles de exigencia: normal y estricto. El segundo se controla mediante la directiva declare(strict_types=1); (en la primera línea del script) e implica un control estricto de los tipos escalares provocando errores de tipo E_RECOVERABLE_ERROR en caso de incumplimiento. Ejemplos.
  • Nuevo operador ?? (coalesce): El operador de doble interrogación ?? permite devolver un valor específico si una variable no está definida. Por ejemplo $username = $_GET('username') ?? null; sería equivalente a $username = isset($_GET('username')) ? $_GET('username') : null;. Ejemplos.
  • Nuevo operador de comparación <=> (spaceship): La operación $a <=> $b devuelve 0 si $a y $b son iguales; devuelve -1 si $a es menor que $b; y devuelve 1 si $a es mayor que $b. Es decir lo mismo que strcmp() pero no limitado a strings. Funciona con variables de tipo int, float, string, array e incluso object. Ejemplos.
  • Sintaxis uniforme de variables: Se ha añadido soporte completo a construcciones de variables complejas, pero con consistencia. Por ejemplo [$obj1, $obj2][0]->prop, $foo->bar()(), (function() { ... })(), "string"->toLower(), etc. Ejemplos.
  • Solución de errores históricos.

Enlaces

miércoles, 2 de diciembre de 2015

Ya está aquí Symfony 3

SensioLabs ha anunciado esta semana la liberación de dos nuevas versiones del popular framework Symfony: La 2.8, que es la última versión de Symfony 2 y cuenta con soporte extendido; y la esperada versión 3.0 que inaugura la tercera iteración del framework PHP.

La versión 2.8 cuenta con retrocompatibilidad con las anteriores versiones de Symfon 2, mientras que la versión 3.0 elimina todas las funciones obsoletas (deprecated) que se han ido sustituyendo en las sucesivas versiones de Symfony 2. Es decir en esencia las versiones 2.8 y 3.0 de Symfony son idénticas excepto que la versión 2.8 mantiene la retrocompatibilidad con las versiones anteriores mientras que la 3.0 no lo hace.

La liberación de las nuevas versión hace que actualmente haya cinco versiones de Symfony con soporte:

Versión LTS Liberación Soporte bugs Soporte seguridad
2.3 x MAY-2013 MAY-2016 MAY-2017
2.6 NOV-2014 JUL-2015 ENE-2016
2.7 x MAY-2015 MAY-2018 MAY-2019
2.8 x NOV-2015 NOV-2018 NOV-2019
3.0 NOV-2015 JUL-2016 ENE-2017

La siguiente versión LTS (Long Time Suport) de Symfony está previsto que sea la 3.3 y la fecha prevista para su liberación es Mayo de 2017. Por ello si hay que empezar un proyecto nuevo con Symfony lo recomendable por ahora es usar la versión 2.8 que tiene 5 años de soporte, teniendo cuidado de no usar funciones obsoletas de Symfony 2 de forma que en el futuro sea factible realizar la migración a Symfony 3.

Enlaces

jueves, 19 de noviembre de 2015

¿Como evitar bloqueos de sesión en PHP?

PHP

Por defecto PHP escribe los datos de la sesión en un fichero en disco. La función session_start() bloquea el fichero de la sesión de forma que nadie más puede leerlo. Ese bloqueo durará hasta que se acaba la ejecución del script o hasta que se libere manualmente usando alguna de las siguientes funciones: session_abort(), session_commit(), session_destroy() o session_write_close().

El problema

La mayoría de los programadores inician la sesión al principio del script, pero la dejan abierta hasta el final. Eso en entornos con múltiples peticiones sobre la misma sesión (por ejemplo con mucho AJAX) es posible que acabe causando un cuello de botella en momentos putuales. En el momento que una petición tarde demasiado en responder (debido por ejemplo a una query complicada) las demás peticiones no podrán acceder al fichero de sesión que estará bloqueado con el resultado de un tiempo de respuesta significativamente elevado. Pero sólo en momentos puntuales.

La solución

Lo más fácil es liberar el fichero de sesión justo después del session_start(). Los datos de sesión seguirán disponibles para lectura a través de la variable superglobal $_SESSION, pero no se podrá encribir nada en la sesión.

<?php
// Start the session
session_start();

// Session is open to read/write ops
$_SESSION['latestRequestTime'] = time();

// Close the session
session_write_close();

// Now session is read-only
$user = $_SESSION['userNAme'];

Alternativas

Si no es posible cerrar la sesión justo después de abrirla (por ejemplo porque haya que escribir datos después de obtenerlos y/o procesarlos) hay algunas alternativas que pueden utilizarse: Guardar la sesión en una base de datos MySQL, ya que el motor de base de datos no bloquea la sesión, o bien guardar la sesión en algún sistema de caché como Redis, Memcache, etc.

Enlaces

jueves, 22 de octubre de 2015

Evitando el consumo excesivo de memoria con Doctrine y Symfony2

Doctrine es el ORM que utiliza el framework Symfony2. Es un producto muy completo, con muchas opciones, pero tiene un pequeño problema cuando se manejan grandes cantidades de información.


El problema

He tenido un problema con un script que mantiene sincronizadas dos bases de datos (una MySQL y otra PostgreSQL, en servidores remotos, aunque no venga al caso). Se trata de un comando de consola de Symfony2 que se ejecuta periódicamente a través de un cron. Llevaba meses funcionando bien hasta que de repente:

Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 1454 bytes).

Vi el problema enseguida: La cantidad de datos a sincronizar ha crecido últimamente; Así que rediseñé el algoritmo para que funcionase con bloques de 500 registros en lugar de tratar de golpe todos los registros.

Pero eso no solucionó el problema.


La solución

Podría haber puesto el sufrido ini_set("memory_limit", -1) pero eso sólo haría que el proceso gastase más y más memoria del sistema. El recolector de basura de PHP no libera los objetos mientras haya referencias apuntando a los mismos y Doctrine internamente mantiene esas referencias a no ser que se liberen manualmente.

Para ello el EntityManager de Doctrine en Symfony2 cuenta con un par de funciones: detach y clear. Veamos un ejemplo:

$em = $this->getDoctrine()->getManager();
$entities = $em->getRepository('...')->findBy(array('...'));
foreach ($entities as $entity) {
    $entity->doSomething();
    // (....)
    $em->detach($entity);
    unset($entity);
}
$em->clear();

La instrucción detach desvincula una entidad del EntityManager; es decir elimina cualquier referencia a la entidad. Los cambios realizados en la entidad, incluyendo su borrado, no se sincronizarán con la base de datos posteriormente a la desvinculación. Por su parte clear desvincula de golpe todas las entidades cargadas en el EntityManager.


Referencias

miércoles, 8 de abril de 2015

¿Como poner en producción un proyecto Symfony 2?

Symfony 2 es uno de los frameworks MVC basados en lenguaje PHP que más de moda están en los últimos tiempos. La documentación oficial de Symfony 2 es muy extensa, pero se hecha en falta una sección dedicada sobre como poner en producción un proyecto ya terminado (o una beta) en un servidor real. Lo que llamamos desplegar el proyecto (del inglés deploy).

Los requisitos de Symfony 2 no son demasiado elevados: Basta un servidor web como Apache o Nginx y PHP 5.3.3 o superior (aunque se recomienda PHP superior a 5.3.16). Siempre es recomendable aunque no obligatorio que sea un servidor dedicado sobre el que tengamos acceso root. Es perfectamente posible desplegar un proyecto Symfony 2 en un servidor compartido aunque eso sí: es necesario tener acceso al shell del servidor (vía SSH típicamente). Symfony 2 no puede desplegarse simplemente subiendo los archivos por FTP.


Conceptos previos

Cualquier proyecto Symfony 2 está compuesto por una carpeta de código fuente del proyecto (src), una carpeta de librerías externas entre las que se incluye el propio framework (vendors), una carpeta de configuración y recursos globales (app) y una carpeta frontal (web). Todas ellas son necesarias, pero no todas tienen la misma importancia.

Carpetas de un proyecto Symfony

  • app: Esta carpeta contiene la configuración del proyecto (subcarpeta app/config), pero también los recursos comunes (subcarpeta app/Resources), los logs (subcarpeta app/logs) y también la cache (subcarpeta app/cache), que es donde se crean una serie de clases autogeneradas que aceleran la ejecución del proyecto (es algo similar a tener código compilado sólo que sigue siendo PHP). En la carpeta app también está la consola que es un componente necesario para instalar el proyecto.
  • src: Esta carpeta contiene el código fuente del proyecto. Internamente el código se divide en bundles y cada bundle puede tener controladores, entidades, vistas, recursos, etc.
  • vendor: Esta carpeta contiene el código fuente de las librerías externas y bundles que usa el proyecto. Se trata de código es open-source que sus creadores ponen a disposición de los programadores para desarrollar sus propios proyectos.
  • web: Esta carpeta contiene el controlador frontal de Symfony 2 (programa app.php). Un proyecto Symfony 2 puede tener más de un controlador frontal, según los distintos entornos de ejecución que se definan: app_dev.php, app_test.php, etc. A la hora de ponerlo en explotación bastaría con el controlador frontal del entorno de producción producción. En la carpeta web también se copian automáticamente los assets del proyecto (imágenes, CSS, JS, etc.)

Entornos de un proyecto Symfony

Dentro de un único proyecto Symfony 2 se pueden definir diversos entornos; típicamente son tres, aunque pueden ser más: desarrollo (dev), pruebas (test) y producción (prod). El primero se usa para desarrollar en proyecto, el segundo es para pasar los test unitarios y funcionales y el tercero es para probar el proyecto tal y como debe funcionar en explotación.

Ojo: Nunca han que confundir los entornos de Symfony (dev, test, prod) con los entornos de una organización. Son cosas distintos. A la hora de poner en producción un proyecto Symfony 2 en un servidor real sólo tendremos en cuenta el entorno de producción. Los demás deben descartarse.

Cada entorno Symfony 2 tiene archivos de configuración diferentes en la carpeta app/config:

  • config.yml: Archivo de configuración común para todos los entornos.
  • config_dev.yml: Archivo de configuración del entorno de desarrollo de Symfony 2. Modifica la configuración de config.yml para el entorno dev. Permite por ejemplo evitar que se envíen mails al ejecutar los test.
  • config_test.yml: Archivo de configuración del entorno Symfony 2 de pruebas unitarias.
  • config_prod.yml: Archivo de configuración específico del entorno de producción.

Además del archivo de configuración puede haber otros archivos con configuración adicional:

  • security.yml: Configuración de la seguridad del proyecto Symfony 2.
  • routing.yml: Configuración de las rutas del proyecto Symfony 2.
  • routing_dev.yml, routing_test.yml, … rutas adicionales por entornos.

Por último existen dos archivos de configuración adicionales:

  • parameters.yml: Este archivo contiene la configuración dependiente de la instalación y es el único archivo que debería variar de un servidor a otro. Sirve por ejemplo para indicar la base de datos a usar, el servidor del API, el servidor de correo, etc. NUNCA debería distribuirse este archivo en una puesta en explotación.
  • parameters.yml.dist: Indica los valores por defecto del archivo “parameters.yml” y es usado por “composer.phar” para crear este último.

Por cada entorno Symfony 2 también habrá un controlador frontal en la carpeta web. Es decir que además del controlador app.php podremos tener app_dev.php y app_test.php. Si por ejemplo creamos un archivo config_beta.yml automáticamente se creará un controlador app_beta.php.

Herramientas

  • composer.phar: Herramienta para resolver dependencias en un proyecto PHP. Usado por Symfony 2 para instalar los vendor y para preparar los entornos.
  • app/console.php: Herramienta interna de Symfony 2 que permite limpiar la cache, instalar los assets y muchas más cosas.

Punto de partida

Para poner en producción un proyecto Symfony 2 hay dos puntos de partida:

  1. Partir de un repositorio (GIT, SVN, etc.)
  2. Partir de código fuente con los vendor.

Permisos

Debido a que es necesario que las carpetas app/cache y app/logs tengan permiso de escritura se recomienda que el usuario Linux que realice la instalación sea el mismo del servidor web (apache, nginx, etc). Si esto no fuera posible debería modificarse el propietario de todos los archivos de esas carpetas como paso final de la instalación o bien dar permisos de escritura sobre esas carpetas. Si esto no se hace no funcionará el proyecto.


Partiendo de un repositorio (GIT, SVN, etc.)

Pasos a seguir

  1. Copiar el proyecto desde el repositorio.
  2. Instalar los vendor.
    php composer.phar install
  3. Borrar controladores frontales y archivos de configuración sobrantes.
    rm -f app/config/*_dev.yml
    rm -f app/config/*_test.yml
    rm -f web/app_dev.yml
    rm -f web/app_test.yml
    (...)
  4. Copiar el archivo app/config/parameters.yml específico de esta instalación.
  5. Limpiar e inicializar la cache de Symfony 2.
    php app/console -e=prod cache:clear
  6. Instalar los assets del entorno de producción.
    php app/console assets:install web --symlink
    php app/console -e=prod assetic:dump
  7. Opcionalmente cambiar el propietario de las carpetas cache y logs.
    chown -R nginx:nginx app/cache
    chown -R nginx:nginx app/logs
  8. Opcionalmente dar permisos de escritura a las carpetas cache y logs.
    chmod -R a+w app/cache
    chmod -R a+w app/logs

Partiendo del código fuente completo (incluido vendor).

Lo normal es que un proyecto Symfony 2 se despliegue desde un repositorio de fuentes (GIT, SVN, etc), pero en ocasiones esto no es posible. En ese caso habrá que subir manualmente el código fuente al servidor, incluyendo la carpeta vendor.

Pasos a seguir

  1. Copiar todo el proyecto Symfony 2 a la carpeta de destino.
  2. Borrar las carpetas de “cache” y “logs”.
    rm -rf app/cache/*
    rm -rf app/logs/*
  3. Borrar controladores frontales y archivos de configuración sobrantes.
    rm -f app/config/*_dev.yml
    rm -f app/config/*_test.yml
    rm -f web/app_dev.yml
    rm -f web/app_test.yml
    (...)
  4. Copiar el archivo app/config/parameters.yml específico de esta instalación.
  5. Limpiar e inicializar la cache de Symfony 2.
    php app/console -e=prod cache:clear
  6. Instalar los assets del entorno de producción.
    php app/console assets:install web --symlink
    php app/console -e=prod assetic:dump
  7. Opcionalmente cambiar el propietario de las carpetas cache y logs.
    chown -R nginx:nginx app/cache
    chown -R nginx:nginx app/logs
  8. Opcionalmente dar permisos de escritura a las carpetas cache y logs.
    chmod -R a+w app/cache
    chmod -R a+w app/logs

miércoles, 7 de enero de 2015

Introducción a MongoDB

MongoDB es una de las bases de datos NoSQL más utilizada. Es un producto open-source, multiplataforma y está escrito en C++, pero su uso es similar al del lenguaje Javascript (objetos JSON), como veremos más adelante.

Una base da detos NoSQL como MongoDB funciona de forma muy distinta a una clásica base de datos relacional: No hay tablas sino colecciones, no hay registros sino documentos, no hay atributos sino campos y como característica más importante: no hay relaciones. Al menos no las hay en el sentido de las bases de datos relacionales, aunque se pueden simular. Tampoco hay SQL. Podría decirse que MongoDB es una base de datos orientada a objetos, ya que los "documentos" de MongoBD son muy similares los "objetos" de por ejemplo Javascript. Tan similares que la interacción con MongoDB se realiza a través JSON (JavaScript Object Notation).

Por ejemplo:

db.books.find({ author: 'George R. R. Martin' });

Una de las principales características de MongoDB, al igual que de otras bases de datos NoSQL, es que los documentos no tienen por que ser homogéneos. Esto quiere decir que dos documentos de la misma colección pueden tener campos diferentes.

Por ejemplo:

db.books.insert({ name: 'A Game of Thrones', author: 'George R. R. Martin' });
db.books.insert({ name: 'A Clash of Kings', year: 1988 });

En este ejemplo ambos documentos tienen distintos campos, estando en la misma colección, pero ambos son válidos en MogoDB. Incluso es posible que dos documentos tengan el mismo campo con distinto tipo. Por ejemplo author podrís ser un string en un documento y un array en otro.


Principales ventajas

  • Rapidez en las consultas.
  • Enorme flexibilidad.
  • Indexación por cualquier campo.
  • Soporta replicación y balanceo de carga.
  • Es multiplataforma: linux, Mac OS X, Windows, ...
  • Tiene drivers para la mayoría de lenguajes de programación: C, C++, PHP, Java, .Net, etc.

Principales inconvenientes

  • Carece de relaciones.
  • No soporta transacciones.

Referencias

miércoles, 3 de diciembre de 2014

Se ha publicado Symfony 2.6

El pasado 29 de noviembre se publicó la nueva versión 2.6 del popular framework PHP Symfony [EN]. Dicha versión incluye multitud de novedades como por ejemplo la inclusión de las llamadas AJAX en la barra de depuración [EN], el nuevo tema para formularios basado en Bootstrap 3 [EN], el nuevo instalador de Symfony [EN] y así hasta 100 cambios, mejoras y correcciones. Puedes consultar la lista completa de cambios de Symfony 2.6 [EN] y las actualizaciones necesarias para pasar de Symfony 2.5 a 2.6 [EN]. Symfony 2.6 se actualizará hasta julio de 2015 y tendrá soporte hasta enero de 2016.

Siguiendo con Symfony recientemente se ha dado a conocer la hoja de ruta para los próximos Symfony 2.7 [EN], con fecha de lanzamiento prevista en mayo de 2015, que será LTS con soporte hasta mayo de 2019 y la última versión de Symfony 2; y el futuro Symfony 3 [EN] que romperá la compatibilidad con las versiones anteriores pero que no supondrá un cambio trágico como lo fue el paso de Symfony 1 a Symfony 2. Las principales novedades que se conocen de Symfony 3 son que se aumentará el requisito de versión de PHP mínimo a PHP 5.5 o PHP 5.6 y que se eliminará código obsoleto, rompiendo compatibilidad con las versiones anteriores.

Referencias

jueves, 13 de noviembre de 2014

PepePhone, la seguridad informática y los diseños inconsistentes

Pepephone es el operador virtual de telefonía móvil mejor valorado por sus usuarios según diversas encuestas. La principal característica de este OMV, más allá de la competencia de precios, es tener los operadores del servicio de atención al cliente en España (concretamente en Palma de Mallorca). Además según la propia Pepephone sus operadores están entrenados para resolver todos los problemas en una llamada y tienen permisos para hacer todos los cambios en el contrato que pida el cliente, pero en cambio tienen prohibido tratar de venderte nada u ofrecerte cambios de tarifas ni nada parecido. La segunda parte no la discuto ya que jamás ningún operador ha de Pepephone ha intentado colarme un cambio de contrato ni nada similar. En cambio eso de que los operadores están entrenados para resolver los problemas del cliente es... ¡discutible!

Contaré mi caso. El pasado 1 de noviembre tuvimos que dejar la empresa sin actividad (congelada) por problemas que no vienen al caso por lo que llamo al 1212 para solicitar un cambio de titular para poner la línea móvil a mi nombre y cambiar la cuenta bancaria. El operador amablemente me informa que tengo que hacerlo desde el área de cliente de la web de Pepephone. Fallo mío. Acostumbrado a tratar con Movistar, Vodafone o Endesa por ejemplo desde cuyas webs se puede hacer de todo menos lo que necesitas (sea lo que sea), no lo había mirado. Cuelgo y voy al área de clientes de Mi Pepephone. Localizo la opción del cambio de titular enseguida, introduzco todos los datos incluido la fotocopia de mi DNI y meeeeeeeeeeeeec: "el email introducido ya está en uso". Vaya por dios. El email es clave única.

Desde el punto de vista del diseño informático, hacer que el email sea clave única y con ello obligar a cambiar el email al cambiar el titular es algo que yo no haría por diversos motivos, pero cosas más raras se han visto. En fin como no me da la gana cambiar de email, uso una cuenta de GMail y sé que puedo alterar la dirección y seguir recibiendo el correo normalmente, lo que hago es poner nombre.apellidos@gmail.com en lugar de nombreapellidos@gmail.com. El email es distinto para el sistema y yo sigo recibiendo emails en la misma cuenta. Le vuelvo a dar a "enviar" y no ocurre nada. Ni un mensaje de confirmación de envío ni un mensaje de error. ¡Nada! ¿Lo habrá enviado? Vuelvo a pulsar enviar y entonces aparece un mensaje de error: "Solicitud ya en curso".

Confuso. Mucho. Un simple mensaje de "formulario enviado" habría bastado para saber si todo iba bien o sino un email de confirmación. Pero no. Nada de nada. Al día siguiente, mosqueado, repito el proceso con el mismo resultado: la primera vez que pulso el botón no hace nada (el formulario queda con todos los datos en modo edición como si no hubiera hecho nada). La segunda vez me muestra el mensaje "Solicitud ya en curso".

Decido dar un voto de confianza a Pepephone, esperando un par de días con la esperanza de que todo funcione bien. Y... sorpresa: ¡lo hace! Un par de días después recibo un email "Te confirmamos que la solicitud de cambio de titular se ha completado con éxito". Y me mandan las nuevas credenciales de acceso, ya con el email nombre.apellidos@gmail.com. Accedo al área de cliente y meeeeeeeeeeeeec: "707 usuario no autorizado". Mi gozo en un pozo. Decido esperar un día más por aquello de que uno es informático y sabe que a veces esas cosas se arreglan "solas" por la noche (cuando pasa el batch, quiero decir). Pero no... ni al día siguiente ni al otro consigo acceder a mi cuenta con las credenciales que me han dado. ¡Aquí nada funciona a la primera!

¿Qué hago ahora? Lo primero será llamar a esos super-operadores de Pepephone, ¿no? Llamo, explico mi problema y el operador empieza a preguntar: DNI, email, número de teléfono, dirección,... número de cuenta. "¿Número de cuenta? Pues ni idea. Estoy en la calle y en estos momentos no tengo forma de saber el número de cuenta". "Pues si no me dice el número de cuenta no puedo resetearle el password, señor". "¿Y no tienes alguna otra forma? Ya te he dado el email, el teléfono, el dni... y lo único que quiero es que me mandéis otra password". "Pues no, señor. Si no me dice todos los datos yo no puedo hacer nada, pero si quiere puede enviar un mail a pepephone@pepephone.com y pedírselo a mis compañeros".

¿Un email? ¡Ya! ¡Seguro que sí! Venga, no pierdo nada: Escribo el email y lo envío. Nos vamos a reír. Cuatro horas después me contestan (se han dado prisa): "Lamentablemente, en la solicitud que nos han remitido, el email solicitado pertenece a otro cliente ya existente. Con el fin de poder atender a la petición que nos habían remitido le agradeceríamos que nos indicasen un correo electrónico alternativo para incluir en su perfil de usuario". Esta vez me lo esperaba. Si no escribo "desde" nombre.apellidos@gmail.com no me resetean el password.

Cabreado ya entro en Mi Pepephone, busco la opción de he olvidado mi contraseña, introduzco ***sólo*** el DNI y el email y dos minutos después recibo el email con la nueva clave de acceso. Y funciona.

Lo que he escrito hasta aquí no es más que un mensaje-pataleta digno de ForoCoches.com. Desde luego llamar al 1212 sin haber buscado antes en Internet fue un error de looser deluxe. Nota mental: borrar el 1212 de la memoria del teléfono (para lo que sirve). Ahora viene la moraleja:

Lo que quería ilustrar con este ejemplo es como algunas empresas pueden complicar innecesariamente un proceso sencillo como es el asignar una nueva clave de acceso, mareando al usuario y haciéndole perder el tiempo. Si para resetear el password desde Internet sólo necesito el email y el dni, ¿Por que para pedirlo por teléfono me tienen que pedir el número de cuenta? Y respecto al email, ¿Qué más da la dirección desde la que escriba? Como si eso no se pudiera simular. ¿Por que los procesos empresariales no son consistentes? Según mi experiencia eso ocurre por falta de coordinación entre departamentos. Es más que habitual que en una empresa relativamente grande no haya nadie que tenga una visión de conjunto de los procesos empresariales relacionados con las TIC (tecnologías de la información y la comunicación) de forma que el mismo proceso funcione de forma diferente dependiendo de que departamento lo ejecute. Y eso es un error.

Las causas de esa descoordinación entre departamentos pueden ser muchas, pero yo apuesto como culpable principal por la externalización salvaje de los servicios de las TIC. A corto plazo puede suponer un ahorro considerable para el empresario, pero si externalizas todo el departamento de informática pierdes conocimiento funcional porque el personal externo suele tener una rotación más elevada que el personal interno. Externalizar la programación por ejemplo puede estar bien siempre que mantengas a los jefes de proyecto y analistas en nómina. No digo que ese haya sido el caso de Pepephone. Hablo de experiencias personales.

domingo, 2 de noviembre de 2014

Symfony 2 avanzado: Cómo pasar el 'locale' a un servicio

Muchas aplicaciones Symfony 2 son multiidioma gracias a la capacidad del popular framework para manejar las traducciones. En este contexto la variable locale contendrá el identificador del idioma. Desde el controlador es muy sencillo obtener el locale a partir del request; basta pedirlo: $this->get('request')->getLocale(). En cambio no es tan sencillo inyectar el locale en el constructor de un servicio debido a los diferentes ámbitos (scopes) que pueden tener los servicios.

Sin embargo hay un truco para hacerlo:

<service
    id="mylocale"
    class="Symfony\Component\HttpFoundation\Request"
    factory-service="request"
    factory-method="getLocale">
</service>

<service
   id="myservice"
   class="%myservice.class%">
   <argument type="service" id="mylocale" on-invalid="null" />
</service>

Es decir, primero creamos un service factory que acceda al Request para obtener el locale y luego inyectamos el service factory en nuestro servicio. el parámetro on-invalid="null" es muy importante para solucionar aquellos casos en que el Request no existe; como por ejemplo los comandos de consola. Al implementar la clase hay que tener en cuenta que es posible que recibamos null en lugar del locale.

class MyService
{
    /**
     * @var string
     */
    private $locale;

    /**
     * @param string $locale
     */
    public function __construct($locale = null)
    {
        $this->locale = $locale;
    }

    // (...)
}

viernes, 31 de octubre de 2014

Javascript avanzado: objetos, clases y prototipos. Introducción

Javascript es un lenguaje muy completo y muy complejo de aprender, sobre todo la parte referente a objetos, clases, herencia, prototipos, etc. Y esto es porque si bien Javascript no soporta de forma nativa esos conceptos de la orientación a objetos que tan claros están en otros lenguajes como Java, C++ o PHP, todos ellos pueden simularse con las funciones nativas del lenguaje.

Por ello voy a iniciar una serie de artículos sobre Javascript Avanzado.


Creación de un objeto simple

var stack = {
    elements: [],
    push: function(elem) {
        this.elements.push(elem);
    },
    pop: function() {
        var elem = this.elements.pop();
        return elem;
    }
};

En Javascript se puede usar la notación JSON para crear objetos sin tener que crear antes una clase. En el ejemplo creamos un objeto llamado stack que tiene un array de elementos y dos métodos: push() y pop(). La variable resultante es directamente un objeto. La mayoría de los lenguajes orientados a objeto no permiten crear objetos sin haber creado antes una clase, pero Javascript sí.

NOTA: Es innecesario crear un objeto stack en Javascript pues la clase Array ya tiene las funciones push() y pop() de forma nativa, pero me sirve para ilustrar el ejemplo.

stack.push(1);
stack.push('string');
stack.push({ id: 1, name: 'test' });
console.log(stack.pop());

Como se ve podemos usar directamente los métodos del objeto stack, pero en cambio no podemos crear nuevos objetos stack, ya que stack es un objeto y no una clase. Por lo tanto el siguiente código dará error:

var s = new stack;

Además en este tipo de objetos simples todos los métodos y miembros son públicos, lo cual quiere decir que podríamos acceder directamente a la lista de elementos elements, lo cual no suele ser correcto desde el punto de vista de la programación orientación a objeto.


Añadiendo miembros y métodos a un objeto simple

Javascript, a diferencia de otros lenguajes de programación orientados a objetos más tradicionales permite añadir nuevos miembros y métodos a un objeto simple tras su creación. Por ejemplo:

stack.top = function() {
    if(this.elements.length < 1) {
        return null;
    }
    else {
        return this.elements[this.elements.length - 1];
    }
};

Así añadimos el método top() al objeto stack que funcionará exactamente igual que si lo hubiéramos puesto desde el principio.


Creación de una clase

En Javascript no podemos crear una clase como tal, pero sí que podemos simularlo mediante una función. Sí, sí... has leído bien: una función. Esa función además funciona como constructor de la clase. Veamoslo con el mismo ejemplo:

var Stack = function() {
    var elements = [];
    this.push = function(elem) {
        elements.push(elem);
    },
    this.pop = function() {
        var elem = elements.pop();
        return elem;
    }
};

En el constructor de la clase Stack inicializamos un array de elementos y definimos las funciones push() y pop(). Ahora Stack es una clase, no un objeto y por lo tanto no podemos hacer lo siguiente:

Stack.push('elem1');
console.log(Stack.pop());

La forma correcta de hacerlo sería creando primero un objeto de clase Stack.

var st = new Stack;
st.push('elem1');
console.log(st.pop());

Además se da el caso de que ahora el miembro elements es privado lo cual significa que no puede ser accedido desde fuera de la clase.


Añadiendo miembros y métodos a una clase Javascript

Anteriormente vimos como añadir métodos a un objeto Javascript. Aquí también podemos añadir miembros y métodos directamente al objeto st, pero como la variable elements no es un miembro de la clase no podremos acceder a ella. Tendríamos que hacer que la variable elements fuera un miembro de la clase

var Stack = function() {
    this.elements = [];
    this.push = function(elem) {
        this.elements.push(elem);
    },
    this.pop = function() {
        return this.elements.pop();
    }
};

var st1 = new Stack;

st1.top = function() {
    if(this.elements.length < 1) {
        return null;
    }
    else {
        return this.elements[this.elements.length - 1];
    }
};

st1.push('e1');
console.log(st1.top());

Hemos añadido el método top() al objeto st que funcionará como si se hubiera añadido en la definición de la clase (función constructora). Sin embargo ese método es exclusivo del objeto st y no estará disponible para otros objetos Stack. ¿Y podemos añadir un método a una clase? Sí; a través del prototipo:

Stack.prototype.top = function(){
    if(this.elements.length < 1) {
        return null;
    }
    else {
        return this.elements[this.elements.length - 1];
    }
};

Ahora tanto st1 como cualquier otro objeto de clase Stack creado con posterioridad tendrán top() entre sus métodos.


Herencia de clases en Javascript

El concepto de la herencia en Javascript también es extraño si estas acostumbrado a otros lenguajes orientados a objeto. Al no existir clases como tales tampoco hay palabras clave como extends o implements. La herencia se hace asignando el prototipo de una función (clase) a otra. Pero la explicación detallada la vamos a dejar para otro artículo.


Referencias

miércoles, 22 de octubre de 2014

Más sobre Composer

El otro día os hablaba de Composer el gestor de dependencias para proyectos en PHP que permite incorporar a nuestros proyecto en PHP multitud de librerías, gestionando sus dependencias de forma magistral. Pues hoy he encontrado el artículo Composer, gestor de dependencias para PHP que amplía la información que yo mismo puse aquí. Os recomiendo su lectura.

Actualización (23/10/2014): Los chicos de desarrolloweb.com han publicado hoy una segunda parte del artículo de Composer llamada Cómo Instalar Composer, donde se detallan las distintas formas de instalar Composer en los más populares sitemas poerativos: Windows, Linux, Max OSX, ...

jueves, 16 de octubre de 2014

Función javascript para formatear un número de teléfono

El título de este artículo lo dice todo: Función javascript para formatear un número de teléfono. Así pues ahí va:

String.prototype.formatPhone = function(sep) {

    if(typeof sep == 'undefined') {
        sep = ' ';
    }

    var num = this.replace(/[^\d\+]/g, '');
    var len = num.length;

    if(len < 7) {
        return num;
    }
    else if(len < 10) {
        return num.replace(
            /(\d{1,3})(\d{3})(\d{3})/,
            '$1' + sep + '$2' + sep + '$3'
        );
    }
    else {
        return num.replace(
            /(\d+)(\d{3})(\d{3})(\d{3})/,
            '$1' + sep + '$2' + sep + '$3' + sep + '$4'
        );
    }
};

Y para usarlo...

    var phone = '[+34] 93 6665544'.formatPhone(' ');
    document.write(phone);

Resultado: +34 936 665 544.

lunes, 13 de octubre de 2014

Manual de buenas prácticas en Symfony2

Me acabo de enterar a través del fabuloso blog Symfony.es de Javier Eguiluz de la presentación del manual oficial de buenas prácticas para desarrollar aplicaciones en Symfony2. Si estás interesado puedes descargarlo en formato PDF en inglés o en español, aunque el propio Javier advierte que el contenido cambiará en los próximos días pues por ahora sólo se ha publicado una versión preliminar. También puedes consultar on-line el manual en Español.

Se trata de una serie de reglas que configuran un conjunto de buenas prácticas que recomiendan desde SensioLabs y que han sido aprobadas por el propio Fabien Potencier. Puedes estar de acuerdo o no con esta guía por lo que si eres desarrollador experto no es necesario que las sigas. Tampoco es obligatorio modificar un proyecto existente para seguirlas. Sin embargo me parece una gran ayuda especialmente para principiantes y para proyectos nuevos. Personalmente no estoy totalmente de acuerdo con todas pero me parece muy interesante especialmente las recomendaciones sobre como crear el bundle de aplicación, y donde poner los recursos como las vistas o las traducciones.

jueves, 28 de agosto de 2014

Herramientas para desarrollo web: Composer

Composer es una de las herramientas fundamentales para desarrollar aplicaciones y páginas web en lenguaje PHP, ya que permite administrar las dependencias de nuestro proyecto con las distintas librerías externas que necesitemos usar. Composer instala las librerías que el proyecto necesita en una carpeta del propio proyecto. Vamos a ver como funciona con un ejemplo:

Supongamos que nuestro proyecto PHP necesita generar archivos Excel. En lugar de crear todo el código necesario desde cero, miramos en Packagist si alguien ha creado una herramienta open-source que haga lo que necesitamos y vemos que existe una librería llamada PHPExcel. Esa librería a su vez necesitará otras, probáblemente. En lugar de descargar el código fuente de la librería y buscar las dependencias dejamos que sea Composer el que resuelva el problema.

Para ello lo primero será tener instalado Composer en el PC, ya sea de forma global o en el directorio raíz del proyecto. Composer es un programa escrito en php que descargaremos y ejecutaremos.

$ curl -sS https://getcomposer.org/installer | php

Obtendremos un archivo llamado composer.phar que luego para instalarlo globalmente podemos moverlo a un directorio del path como /usr/bin o /usr/local/bin, dándole permisos de ejecución.

$ mv composer.phar /usr/local/bin/composer
$ chmod a+x /usr/local/bin/composer

Una vez tenemos Composer instalado de forma global, creamos el archivo composer.json en la raíz de nuestro proyecto:

{
    "require": {
        "phpoffice/phpexcel": "dev-master"
    }
}

Y entonces usamos composer para que resuelva las dependencias:

$ composer install

La ejecución de composer crea la carpeta vendor y descarga automáticamente la librería phpexcel y las dependencias de ésta si las hay. También crea un archivo llamado autoload.php que será necesario incluir en nuestro proyecto para usar las librerías creadas por composer.

<?php
require __DIR__ .'/vendor/autoload.php';

Requerimientos:

Al ser un programa escrito en PHP Composer es multiplataforma por lo que funciona tanto en Linux como en OSX y en Windows. Necesita una versión de PHP 5.3.2 o superior y puede requerir modificar alguna configuración en php.ini, pero el propio instalador informa de cualquier incompatibilidad. Además es conveniente tener instalado Git, Svn u otras herramientas para el control de código fuente.


Enlaces:

martes, 29 de julio de 2014

Silex, un micro-framework para PHP basado en Symfony2

Symfony2 es uno de los frameworks para PHP más completos, versátiles y potentes que existen actualmente en el mercado. Pero, ¿Qué ocurre si no necesitamos tanta potencia? ¿Que hacemos si queremos desarrollar una pequeña página corporativa donde la potencia de Symfony2 es más un estorbo que una ayuda? En esos casos en lugar de usar Symfony u otro framework potente como Zend se suele optar por personalizar un Wordpress, un Joomla o cualquier otro CMS. El problema entonces es que perdemos el control del desarrollo en temas como gestión de permisos, teniendo que adaptar nuestros requerimientos a lo que pueda hacer el CMS elegido. Sin embargo existe una tercera vía: El uso de un micro-framework que sin ser tan potente como un Symfony o un Zend nos proporcione la suficiente versatilidad para desarrollar una pequeña página web de forma ágil. Y en este caso la propia SensioLabs y Fabien Potencier, creadores de Symfony, nos dan la solución: Silex.

Silex es un micro-framework para lenguaje PHP basado en componentes de Symfony2. Funciona con PHP 5.3 o superior y tiene licencia MIT (código fuente libre). La gran potencia de Silex es que aprovecha gran parte de los componentes del núcleo de Symfony2, que están sobradamente probados, pero en cambio en mucho más fácil de usar que Symfony2. El paquete básico de Silex permite desarrollar páginas web desde cero, proporcionando un sencillo sistema de definición de rutas propio y poco más. Sin embargo es posible añadir a Silex multitud de componentes externos que también usa Symfony: desde Twig hasta Doctrine, pasando por Swiftmailer y algunos de los componentes más potentes de Symfony como sus formularios, su sistema de validación, su sistema de traducciones, etc.

La documentación de Silex es muy completa, en la línea de los otros productos de SensioLabs.


Ejemplo: Hola mundo en Silex

require_once __DIR__ . '/../vendor/autoload.php';

$app = new Silex\Application();

$app->get('/', function() {
    $output = 'Hola mundo.';
    return $output;
});

$app->run();

viernes, 11 de julio de 2014

Nueva imágen corporativa y nueva web

Este mes estamos de celebración en iFraktal pues estrenamos, logotipo, imagen corporativa y página web. El diseño y las tendencias están en constante cambio y eso nos obliga también a nosotros a seguir esa ola de renovación constante.

Nosotros somos los primeros en aconsejar a nuestros clientes que una vez la página web está acabada, lo que hay que hacer es un proceso de renovación constante, algo que atraiga siempre la atención hacia su carta de presentación, es decir, su página web. Es por ello que nosotros nos hemos aplicado nuestro própio consejo y "nos hemos lavado la cara".

Así mismo hemos inaugurado un nuevo blog corporativo integrado dentro de la nueva página web, dejando este blog, que también renovaremos estéticamente, como herramienta de soporte técnico para desarrolladores internos y externos. Seguiremos por supuesto publicando información técnica, artículos y trucos siempre que podamos.


Enlaces de interés