Script Inside

Recuperar y migrar un WordPress comprometido

2026-03-09T16:14:00.005+01:00

Hace unos días tuve que migrar un WordPress a un servidor nuevo después de que el anterior quedara comprometido. Cuando llegas a un punto en el que faltan binarios del sistema, hay procesos extraños o cron jobs que no reconoces, seguir intentando limpiar la máquina deja de tener sentido. En estos casos prefiero recuperar los datos necesarios y reconstruir el servidor desde cero. Este fue exactamente el proceso que seguí.

1. Recuperar el WordPress del servidor antiguo

Lo primero fue sacar la carpeta completa del WordPress.

En mi caso estaba en:

/var/www/html/wordpress

Desde mi máquina local ejecuté:

scp -r root@<server_ip>:/var/www/html/wordpress .

Con esto copié todo el código del sitio a mi máquina local.

2. Recuperar la base de datos

Para identificar la base de datos revisé el wp-config.php:

grep DB_ wordpress/wp-config.php

Una vez identificado el nombre de la base de datos y el usuario, generé el dump.

mysqldump --no-tablespaces -u wordpress_user -p wordpress_db > /root/wordpress_no_tablespaces.sql

Tuve que usar --no-tablespaces porque el usuario no tenía permisos PROCESS.

Después lo copié a local:

scp root@<server_ip>:/root/wordpress_no_tablespaces.sql .

3. Recuperar configuración del servidor

También guardé algunas configuraciones del servidor antiguo por si necesitaba replicar algo.

nginx

scp -r root@<server_ip>:/etc/nginx ./backup_server/

PHP

scp -r root@<server_ip>:/etc/php ./backup_server/

certificados SSL

scp -r root@<server_ip>:/etc/letsencrypt ./backup_server/

logs

scp -r root@<server_ip>:/var/log/nginx ./backup_server/

Al final terminé con esta estructura:

wordpress/
wordpress_no_tablespaces.sql
backup_server/nginx
backup_server/php
backup_server/letsencrypt
backup_server/logs

4. Probar el WordPress en local con Docker

Antes de restaurar nada en un servidor nuevo preferí comprobar que el backup funcionaba correctamente y que no había nada extraño en el código. Para hacerlo monté un entorno local con Docker.

La idea era reproducir el stack del servidor:

nginx
php-fpm
mysql

Primero construí el entorno:

docker compose up -d --build

Luego importé la base de datos dentro del contenedor:

docker exec -i wp_db mysql -u root -pwordpress_root_password wordpress_db < wordpress_no_tablespaces.sql

Después accedí al WordPress desde el navegador:

http://localhost

Esto me permitió comprobar:

que el sitio cargaba correctamente
que la base de datos estaba intacta
que los plugins funcionaban
que no había código sospechoso

Además ejecuté algunas comprobaciones básicas.

Buscar PHP en uploads:

find wordpress/wp-content/uploads -name "*.php"

Buscar funciones sospechosas:

grep -R "base64_decode(" wordpress

Una vez comprobado que todo funcionaba correctamente continué con la migración.

5. Montar un servidor nuevo

Con el backup verificado monté un servidor nuevo con Ubuntu 24.04.

Actualicé el sistema:

apt update
apt upgrade -y

6. Instalar el stack del servidor

Ubuntu 24.04 instala PHP 8.3 por defecto, pero en mi caso quería utilizar PHP 8.4, así que añadí el repositorio de PHP mantenido por Ondřej Surý.

Primero instalé las herramientas necesarias:

apt install -y software-properties-common

Después añadí el repositorio:

add-apt-repository ppa:ondrej/php
apt update

Una vez añadido el repositorio instalé nginx, MySQL y PHP 8.4 con las extensiones necesarias para WordPress:

apt install -y nginx mysql-server php8.4-fpm php8.4-mysql php8.4-cli php8.4-curl php8.4-gd php8.4-mbstring php8.4-xml php8.4-zip php8.4-intl unzip certbot python3-certbot-nginx fail2ban

Después comprobé la versión de PHP instalada:

php -v

La salida debería mostrar algo similar a:

PHP 8.4.x (cli)

También verifiqué que el socket de PHP-FPM estaba disponible:

ls /run/php/

Debería aparecer:

php8.4-fpm.sock

Este es el socket que luego se utiliza en la configuración de nginx.

7. Crear la base de datos

Entré en MySQL:

mysql

Creé la base de datos y el usuario:

CREATE DATABASE wordpress CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'wordpress_user'@'localhost' IDENTIFIED BY 'your_secure_password';
GRANT ALL PRIVILEGES ON wordpress.* TO 'wordpress_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

8. Subir el dump al servidor nuevo

Desde mi máquina local:

scp wordpress_no_tablespaces.sql root@<new_server_ip>:~

Importé la base de datos:

mysql -u wordpress_user -p wordpress < ~/wordpress_no_tablespaces.sql

9. Subir el WordPress

scp -r wordpress/* root@<new_server_ip>:/var/www/<domain>

Permisos correctos:

chown -R www-data:www-data /var/www/<domain>

10. Configurar nginx

Creé el virtual host:

nano /etc/nginx/sites-available/<domain>

Configuración básica:

server {
    listen 80;
    server_name <domain>;

    root /var/www/<domain>;
    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.4-fpm.sock;
    }
}

Activé el sitio:

ln -s /etc/nginx/sites-available/<domain> /etc/nginx/sites-enabled/

11. Activar HTTPS

certbot --nginx -d <domain>

12. Comprobaciones finales

Verificar PHP en uploads:

find /var/www/<domain>/wp-content/uploads -name "*.php"

Comprobar cronjobs:

crontab -l
ls /etc/cron*

Verificar renovación SSL:

certbot renew --dry-run

Conclusión

Cuando un servidor ha sido comprometido realmente, la forma más rápida de volver a tener control sobre el sistema es reconstruir el entorno desde cero.

En mi caso el proceso fue:

recuperar WordPress y base de datos
validar el backup en Docker
montar un servidor limpio
restaurar el sitio

Puede parecer más trabajo que intentar limpiar el servidor original, pero a largo plazo suele ser mucho más seguro.

Instalar llnode en macOS Big Sur

2021-04-07T09:57:00.002+02:00

El complemento llnode agrega la capacidad de inspeccionar el código fuente JavaScript a las funciones de depuración estándar de C / C ++ cuando se trabaja con procesos Node.js o volcados de núcleo en LLDB. Digamos que es la herramienta imprescindible si queremos detectar fallos en la gestión de memoria en nuestro código.

Entorno

macOS Big Sur 11.2.3
node 14.15.4
lldb-1200.0.44.2

Al ser llnode un plugin para lldb necesitamos instalar este primero, en el caso de macOS es suficiente con instalar las herramientas de consola de Xcode, nada más, no es necesario tener la versión completa instalada.

sudo xcode-select --install

Para comprobar que todo es correcto podemos utilizar

lldb --version

Ahora vamos a instalar llnode y la mejor manera es utilizando brew:

brew install llnode

Es importante tener en cuenta que esto solo nos instala el plugin pero no lo vincula con lldb ni genera un comando con el que podamos llamar a llnode desde consola directamente así que es normal que una vez instalado tengamos esto si lo intentamos llamar desde consola:

% llnode
zsh: command not found: llnode

Para comprobar realmente que el plugin se ha instalado correctamente podemos utilizar el siguiente truco, que además nos dará la ruta donde se ha instalado, dato necesario para los siguientes pasos.

brew link llnode

Warning: Already linked: /usr/local/Cellar/llnode/3.2.0_1
To relink:
  brew unlink llnode && brew link llnode

Una vez instalado tenemos que vincular (o agregar) llnode a nuestra instalación de lldb. Para activar este plugin basta con editar el archivo ~/.lldbinit y agregar la siguiente línea:

plugin load /usr/local/Cellar/llnode/3.2.0_1/llnode.dylib

Ahora solo nos queda utilizarlo. llnode puede correr con un proceso existente o con un volcado del core, en este post voy a utilizar la segunda opción. Primero necesitamos el PID del proceso de Node sobre el cual queremos generar el volcado, una vez tenemos este dato (ps aux | grep node) generamos el volcado:

lldb --attach-pid {PID} -b -o 'process save-core "core.{PID}"'

Con esto ya podemos utilizar llnode

lldb
(lldb) target create node -c core.{PID}

(lldb) v8 nodeinfo
(lldb) v8 findjsobjects

Podéis encontrar información adicional en estos enlaces, pero no sigáis esas instrucciones de instalción

Github page
Usage tutorial

Otras formas de instalar llnode en Big Sur pueden dar diferentes errores, como los siguientes:

npm install -g llnode

Reading lldb version...
xcode-select: error: tool 'xcodebuild' requires Xcode, but active developer directory
'/Library/Developer/CommandLineTools' is a command line tools instance
Error: Command failed: xcodebuild -version
xcode-select: error: tool 'xcodebuild' requires Xcode, but active developer directory
'/Library/Developer/CommandLineTools' is a command line tools instance

brew update && brew install --with-lldb --with-toolchain llvm
Error: invalid option: --with-lldb

Migrando zend expressive a mezzio

2020-04-29T10:23:00.000+02:00

Hace ya un tiempo se gestaron cambios en Zend, ahora es Láminas y el soporte a Zend Framework tal y lo conocíamos ha caducado, ahora el Framework es Mezzio.

Esta es la equivalencia de los nuevos paquetes, la mayoría de cambios son solo de namespaces:

zendframework/zend-auradi-config => laminas/laminas-auradi-config
zendframework/zend-cache => laminas/laminas-cache
zendframework/zend-code => laminas/laminas-code
zendframework/zend-component-installer => laminas/laminas-component-installer
zendframework/zend-config-aggregator => laminas/laminas-config-aggregator
zendframework/zend-db => laminas/laminas-db
zendframework/zend-debug is abandoned, you should avoid using it. No replacement was suggested.
zendframework/zend-diactoros => laminas/laminas-diactoros
zendframework/zend-escaper => laminas/laminas-escaper
zendframework/zend-eventmanager => laminas/laminas-eventmanager
zendframework/zend-expressive => mezzio/mezzio
zendframework/zend-expressive-aurarouter => mezzio/mezzio-aurarouter
zendframework/zend-expressive-authentication => mezzio/mezzio-authentication
zendframework/zend-expressive-authentication-oauth2 => mezzio/mezzio-authentication-oauth2
zendframework/zend-expressive-csrf => mezzio/mezzio-csrf
zendframework/zend-expressive-flash => mezzio/mezzio-flash
zendframework/zend-expressive-helpers => mezzio/mezzio-helpers
zendframework/zend-expressive-router => mezzio/mezzio-router
zendframework/zend-expressive-session => mezzio/mezzio-session
zendframework/zend-expressive-session-ext => mezzio/mezzio-session-ext
zendframework/zend-expressive-template => mezzio/mezzio-template
zendframework/zend-expressive-tooling => mezzio/mezzio-tooling
zendframework/zend-httphandlerrunner => laminas/laminas-httphandlerrunner
zendframework/zend-problem-details => mezzio/mezzio-problem-details
zendframework/zend-servicemanager => laminas/laminas-servicemanager
zendframework/zend-stdlib => laminas/laminas-stdlib
zendframework/zend-stratigility => laminas/laminas-stratigility
zfcampus/zf-composer-autoloading => laminas/laminas-composer-autoloading
zfcampus/zf-development-mode => laminas/laminas-development-mode

El proceso de actualización es bastante sencillo y automático, lo unico que necesitamos es el paquete para la migración, que instalaremos con composer

# composer global require laminas/laminas-migration
Changed current directory to /root/.composer
Using version ^1.1 for laminas/laminas-migration
./composer.json has been created
Loading composer repositories with information
Updating dependencies (including require-dev)
operations: 7 installs, 0 updates, 0 removals
  - Installing psr/container (1.0.0): Loading from cache
  - Installing symfony/service-contracts (v2.0.1): Loading from cache
  - Installing symfony/polyfill-php73 (v1.14.0): Downloading (100%)
  - Installing symfony/polyfill-mbstring (v1.14.0): Downloading (100%)
  - Installing symfony/console (v5.0.5): Downloading (100%)
  - Installing laminas/laminas-zendframework-bridge (1.0.1): Downloading (100%)
  - Installing laminas/laminas-migration (1.1.0): Downloading (100%)
symfony/service-contracts suggests installing symfony/service-implementation
symfony/console suggests installing symfony/event-dispatcher
symfony/console suggests installing symfony/lock
symfony/console suggests installing symfony/process
symfony/console suggests installing psr/log (For using the console logger)
Writing lock file
Generating autoload files

Luego debemos asegurarnos que el directorio de composer está en el path

# composer global config home
Changed current directory to /root/.composer
/root/.composer
# export PATH=/root/.composer/vendor/bin:$PATH

Y ejecutamos el asistente

# laminas-migration migrate -e data

Migrating project at path "/usr/share/nginx/html/api" to Laminas
================================================================

Injecting laminas-dependency-plugin into composer.json
Performing migration replacements
Injecting Laminas\ZendFrameworkBridge\ConfigPostProcessor into /usr/share/nginx/html/api/config/config.php

                                                                                                                        
 [OK] Migration complete!                                                                                               
                                                                                                                        

 Next steps:
 - Perform a diff to verify the changes made.
 - Run "composer install".
 - Run any tests (unit tests, integration tests, end-to-end tests, etc.).

Es muy importante el parámetro -e porque aqui debemos incluir todos nuestros directorios de datos que no contengan código (imágenes, backups, etc...), porque de no hacerlo tendremos error de memoria.

PHP Fatal error:  Allowed memory size of 536870912 bytes exhausted (tried to allocate 285822984 bytes) 
in /root/.composer/vendor/laminas/laminas-zendframework-bridge/src/Replacements.php on line 30

CentOS 8 ahora viene con DNF

2020-02-25T13:12:00.004+01:00

Uno de los cambios más radicales en CentOS 8 ha sido la sustitución del gestor de paquetes YUM por DNF, en la mayoría de los sitios comentan que la transición es casi trivial, pero esto no es del todo cierto, en este post veremos algunas consideraciones sobre este cambio.

Primero veamos las 3 razones que se esgrimen para haber levado a cabo este cambio:

La documentación de yum es casi inexistente para ampliar su funcionalidad
YUM no soporta Python 3
El gestor de dependencias utilizado por DNF es más estándar, ya vine siendo utilizado por SUSE hace mucho tiempo dentro de zypper.

Ahora bien, pese a que la sintaxis es básicamente la misma el manejo de repositorios no lo es tanto, se van a poder agregar como se hacía con YUM, incluso dejando en el mismo directorio los archivos .repo pero algunas cosas cambian, en mi caso pondré las diferencias para trabajar con algunas librerías de PHP. Por ejemplo, en vez de habilitar diferentes repos para una u otra versión ahora se habilita un módulo para la versión de PHP y las librerías se instalan utilizando ese modulo.

dnf module -y install php:remi-7.4

Para instalar repositorios podemos hacerlo de la siguiente manera si es un archivo .repo

dnf -y install dnf-plugins-core
dnf config-manager --add-repo https://xxxxxx/xxxxxx.repo

O si viene dentro de un .rpm

dnf -y install https://xxxxxx/xxxxxx.rpm

Una de las diferencias que he notado es que con este sistema de módulos algunos repos no vienen activos por defecto, con lo cual no se resuelven correctamente las dependencias, por ejemplo, dan problemas las librerías de mongodb e imagick, para instalarlas es necesario especificar el repo de sus dependencias, un paso más que no teníamos con YUM.

dnf --enablerepo=PowerTools -y install tinyxml2
dnf -y install mediainfo php-pecl-imagick

dnf --enablerepo=remi -y install libbson mongo-c-driver
dnf -y install php-pecl-mongodb

Los errores de no hacerlo así serían los siguientes

Problem 1: cannot install the best candidate for the job
- nothing provides libbson(x86-64) >= 1.16.1 needed by php-pecl-mongodb-1.7.1-1.el8.remi.7.4.x86_64
- nothing provides mongo-c-driver-libs(x86-64) >= 1.16.1 needed by php-pecl-mongodb-1.7.1-1.el8.remi.7.4.x86_64
Problem 2: package mediainfo-19.09-1.el8.x86_64 requires libmediainfo.so.0()(64bit), but none of the providers can be installed
- conflicting requests
- nothing provides libtinyxml2.so.6()(64bit) needed by libmediainfo-19.09-1.el8.x86_64

SQL Server, columnas calculadas

2020-02-12T11:46:00.000+01:00

Aquí os dejo algunos apuntes básicos sobre las columnas calculadas en SQL Server.

¿Cuando se calculan?

Depende de cómo defina la columna calculada. Una columna calculada PERSISTIDA se calculará y luego se almacenará como datos dentro de la tabla al ser creada. Si no define la columna como PERSISTIDA, se calculará cada vez que se ejecute una consulta que la incluya.

Mas info aquí.

Tablas temporales o versionadas

La modificación del esquema de una tabla versionada por el sistema (tablas temporales) falla porque no se admite agregar una columna calculada mientras el versionado del sistema está activado. Para solucionarlo:

Primero desactivar el versionado
Luego agregar la columna calculada a la tabla base
Verificar el tipo de la columna calculada resultante
Agregar la columna con el tipo estático apropiado a la tabla de historial (tabla temporal o tabla versionada)
Volver a activar el versionado

Otra cosa a tener en cuenta es que una columna calculada que utiliza una función definida por el usuario no está permitida dentro de una tabla temporal porque realiza el acceso a los datos del usuario o del sistema, o se supone que realiza este acceso. Se asume que una función realiza de forma predeterminada el acceso a datos si no está vinculada al esquema (schemabound).

Persistir columna no determinista

Una columna calculada no se puede persistir si la columna no es determinista.

Las funciones deterministas siempre devuelven el mismo resultado cada vez que se llaman con un conjunto específico de valores de entrada y el mismo estado de la base de datos. Las funciones no deterministas pueden devolver resultados diferentes cada vez que se llaman con un conjunto específico de valores de entrada, incluso si el estado de la base de datos al que acceden sigue siendo el mismo. Por ejemplo, la función AVG siempre devuelve el mismo resultado si los datos no cambian, pero la función GETDATE, que devuelve el valor actual de fecha y hora, siempre devuelve un resultado diferente. Mas información aquí y aquí.

Ciclos de lanzamiento en PHP, curiosidades

2020-02-10T17:46:00.001+01:00

A raíz de la cada vez más cercana versión 8 de PHP y sus esperadas mejoras han surgido algunos bulos sobre su fecha de lanzamiento, hasta ser confirmada finalmente el 10 de febrero con el siguiente tweet:

En este tweet se habla de los ciclos de lanzamiento de PHP, puede parecer algo trivial o sin importancia, pero desde la versión 7, no sólo ha mejorado el lenguaje, sino la forma de trabajar del equipo de desarrollo. Si tomamos por ejemplo los 414 lanzamientos que se han publicado desde junio de 2003, de ellos 27 alfas, 30 betas y 52 candidatas, podemos ver una mayor organización y previsible agenda en los mismos.

Por citar un ejemplo, mientras en php 5 no siempre se publicaban alfas, betas o RC, en php 7 si, y además periódicamente, las versiones 0,1,2,3 y 4 de php 7 comparten los mismo tiempos, desde el lanzamiento de la primera beta hasta el lanzamiento de la primera versión candidata pasan exactamente 42 días, y también para la mayoría de transiciones de alfa a beta (7.1, 7.2 y 7.4), el paso de RC a versión estable si es ligeramente diferente, en php 5 la horquilla era desde 42 días con php 5.5 a 117 con la 5.0, mientras en php 7 van desde los 84 a los 104 días.

De los lanzamientos también podemos deducir que el día preferido para sacar una nueva versión es el jueves, se nota claramente en el siguiente gráfico, y como nota importante, en php 7 no han tenido lanzamientos los fines de semana, con php 5 si, concretamente 5 (4 en sábado y 1 en domingo).

Reafirmando el tweet de Nikita Popov podemos ver que en php 7 los lanzamientos de versiones iniciales (me refiero a 7.0.0, 7.1.0, etc) siempre han sido en noviembre o diciembre, no así con php 5 donde 7 lanzamientos de este tipo se hicieron en 5 meses distintos.

Y para terminar os dejo estos 3 gráficos, el primero con la evolución en el tiempo de cada lanzamiento, el segundo con la vida útil de cada uno (teniendo en cuenta el tiempo de desarrollo como el tiempo que pasa entre la primera beta o alfa publicada y la publicación de la versión 0 y tiempo en producción desde esta versión 0 hasta la última actualización publicada) y el tercero para ver cómo se han solapado las diferentes versiones en el tiempo.

Si queréis la base de datos dejadme un comentario y os paso la tabla.

Instalar libreria PHP image magick en MacOS Catalina

2020-02-10T16:00:00.000+01:00

Primero necesitamos instalar los pre requisitos, en caso que no los tengamos

brew install imagemagick

Luego ejecutamos la instalación con PECL y le damos INTRO a cada pregunta para aceptar los valores por defecto

pecl install imagick

Please provide the prefix of ImageMagick installation [autodetect] :

Ignorar los siguientes errores

cp: /private/tmp/pear/temp/imagick/build/php.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/shtool: Permission denied
cp: /private/tmp/pear/temp/imagick/build/libtool.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/ax_check_compile_flag.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/ax_gcc_func_attribute.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/php_cxx_compile_stdcxx.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/pkg.m4: Permission denied
cp: /private/tmp/pear/temp/imagick/build/config.guess: Permission denied
cp: /private/tmp/pear/temp/imagick/build/config.sub: Permission denied
cp: /private/tmp/pear/temp/imagick/build/ltmain.sh: Permission denied
cp: /private/tmp/pear/temp/imagick/build/Makefile.global: Permission denied
cp: /private/tmp/pear/temp/imagick/run-tests.php: Permission denied

Instalar librería memcached para PHP en MacOS Catalina

2020-02-06T12:09:00.000+01:00

Primero necesitamos instalar los pre requisitos, en caso que no los tengamos

brew install zlib
brew install pkg-config
brew install libmemcached

Luego ejecutamos la instalación con PECL y le damos INTRO a cada pregunta para aceptar los valores por defecto

pecl install memcached

libmemcached directory [no] : 
zlib directory [no] : 
use system fastlz [no] : 
enable igbinary serializer [no] : 
enable msgpack serializer [no] : 
enable json serializer [no] : 
enable server protocol [no] : 
enable sasl [yes] : 
enable sessions [yes] :

Ignorar el siguiente error

Warning: Use of undefined constant name - assumed 'name' (this will throw an Error in a future version of PHP) in Builder.php on line 407

SQL Server schemabinding

2020-02-05T12:35:00.002+01:00

Este post es una traducción al castellano de este otro.

Cuando se utiliza la palabra clave SchemaBinding al crear una vista o función, lo que hace es vincular la estructura a las tablas o vistas subyacentes. ¿Qué significa? Significa que mientras un objeto exista como un objeto vinculado, está limitado en los cambios que se pueden realizar sobre él por las tablas o vistas que lo referencian. Si una tabla es referenciada por una función o vista vinculada, solo las columnas a las que hace referencia la función o la vista no se pueden modificar, el resto si.

Cuando tienes objetos vinculados en una base de datos:

No puedes cambiar la intercalación (collation) de la base de datos.
No puedes usar SELECT * en las vistas vinculadas.
No puedes ejecutar sp_refreshview en las vistas vinculadas.
Puedes realizar cualquier cambio en la tabla origen que no afecte la estructura de las columnas enlazadas.
Puedes averiguar si un objeto está vinculado al esquema mirando la columna is_schema_bound en sys.sql_modules o la función del sistema OBJECTPROPERTY (object_id, ‘is_schema_bound’).
Si haces referencia a una vista o función en una vista o función vinculada, entonces esa vista o función también debe estar vinculada.
Los objetos que están vinculados (tablas / vistas) no se pueden borrar mientras otro objeto los referencia.
Los objetos que están vinculados al esquema pueden cambiar su definición, pero los objetos a los que hacen referencia los objetos vinculados al esquema no pueden cambiar su definición. O sea, puedes cambiar la vista vinculada pero no los campos de las tablas de origen.

El enlace de esquema establece efectivamente que los metadatos que se crean en el momento de la creación del objeto pueden ser confiables en todo momento y no es necesario el uso de sp_refreshsqlmodule.

El enlace de esquema también puede aumentar significativamente el rendimiento de las funciones definidas por el usuario.

Aún así schemabinding no es una herramienta de uso común, cada vez es más frecuente a raiz de las vistas indexadas, pero no exclusivamente. Se puede utilizar también para bloquear la estructura de una vista o función crítica pues, al incluir esta cláusula, se protege la vista o función de cambios inesperados en las tablas subyacentes

Instalar PHP 7.4+ en MacOS Catalina 10.15+

2020-02-04T15:20:00.004+01:00

Ahora instalar PHP es muchísimo más sencillo en Mac, con un solo comando podemos hacerlo tal y como se hace en CentOS.

brew install php
php -v
PHP 7.4.2 (cli) (built: Jan 22 2020 06:30:58) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
    with Zend OPcache v7.4.2, Copyright (c), by Zend Technologies

Si la versión de PHP no es la última, es posible que hayas instalado una versión previa utilizando el script de liip, si es tu caso te recomiendo desinstalarlo, el problema es si liip te lo ha instalado en /usr/bin/php en vez de /usr/local/bin/php, que seguramente es tu caso porque brew lo instala en esta última ubicación.

Desisntalar PHP instalado con liip

sudo rm -rf /usr/local/php*

Luego necesitas deshabilitar System Integrity Protection, para ello tienes que reiniciar en modo recuperación (Command + R) y sin elegir ninguna opción del menú, ir al Terminal y ejecutar csrutil disable, para más info puedes consultar este otro enlace. Una vez deshabilitado, reinicias y puedes borrar el archivo rm -rf /usr/bin/php.

Con estos sencillos pasos deberías tener habilitado php en su última versión. En un futuro para actualizarlo bastaría con ejecutar brew upgrade php.

Actualizar a PHP 7.3+ en MacOS Mojave 10.14+

2019-07-31T16:21:00.001+02:00

Mac suele venir con alguna versión de PHP, pero al igual que CentOs estas versiones nunca son las últimas. Buscando por internet hay muchísimos manuales que te permiten actualizar a la última versión de PHP en MacOS, pero todo son para apache, si necesitas ejecutar PHP en el terminal siempre vas a tener la versión por defecto. Por suerte este se puede modificar muy fácilmente.

Para instalarlo he seguido los pasos de este manual, que, aunque en la página oficial diga que el soporte es hasta la versión 10.13 de OSX para la 10.14 también funciona.

Luego necesitamos editar nuestro terminal para que la versión sea la correcta, esto lo haremos de manera sencilla así:

nano ~/.bash_profile

Agregamos la siguiente línea

export PATH="/usr/local/php5/bin:$PATH"

CTRL+O CTRL+X

source ~/.bash_profile

Habilitar CORS en GraphQL y Zend Expressive 3

2019-01-03T15:50:00.000+01:00

Encontré este artículo que me dió la pista de como hacerlo, pero es de 2017, con lo cual me encontré con múltiples errores. Aquí os dejo la guía detallada de cómo habilitar CORS para las últimas versiones de GraphQL y demás librerias implicadas.

Instalamos las dependencias

composer require tuupola/cors-middleware

composer require zendframework/zend-problem-details

Creamos la factoría dónde pondremos nuestros valores por defecto y la gestión de errores en JSON (disponible en github)

Editamos el archivo de dependencias

Tuupola\Middleware\CorsMiddleware::class => App\Factory\CorsMiddlewareFactory::class

Y por último habilitamos el middleware en pipeline.php

use Tuupola\Middleware\CorsMiddleware;

...

// $app->pipe(ImplicitOptionsMiddleware::class);
$app->pipe(CorsMiddleware::class);

Constitución cubana 1976 vs 2018

2018-11-12T17:14:00.001+01:00

Este post es bastante offtopic. Por curiosidad, y sin ser lingüista ni hacer un análisis muy detallado, he pillado la constitución cubana de 1976 y la he comparado con el nuevo proyecto que se quiere aprobar ahora. La comparación no va más allá que ver el uso de las palabras, si algún lingüista le apetece, yo encantado le paso los datos para que haga un análisis más profundo.

En fin, sin enrrollarme más, vamos al grano.

¿Qué palabras son las más utlizadas?

Aquí no hay mucha diferencia, ¡qué sorpresa! Quitando artículos, conjunciones, preposiciones, etc..., nos quedaría que en ambas constituciones las palabras más utilizadas son: estado, poder, popular, nacional, ley (leyes), asamblea, consejo, constitución, república.

¿Qué hay de nuevo?

En el nuevo proyecto se han agregado alrededor de mil palabras nuevas, entre ellas, las más utilizadas son: conformidad, ministro, gobernador, garantizar, directivos, familias, información, autonomía, inversión, proteger, desastre, magistrados, financiero, etc...

¿Qué se ha quitado?

Alrededor de 500 palabras han sido eliminadas en el nuevo documento, entre ellas: agricultores, méritos, gratuita, facilidades, centrales, agropecuaria, escuela, disolver, cuadros, etc...

Cómo decía antes, aqui no hago ningún análisis profundo, cada uno que saque sus propias conclusiones.

GraphQL en Zend Expressive 3

2018-06-29T10:43:00.000+02:00

Voy a intentar hacer una guia de paso a paso para utilizar GraphQL en Zend Expressive 3. Existe algo de documentación por la red pero, o está incompleta o desactualizada, por eso me he decidido a hacer este manual.

¿Que vamos a utilizar?

La última versión de Zend Expressive 3 y la implementación de GraphQLpara PHP hecha por webonyx.

Otro día hablaré del por qué Zend Expressive.

¿Comenzamos?

Lo primero es crear un proyecto

$ composer create-project zendframework/zend-expressive-skeleton graphql-expressive

Recuerda que el directorio graphql-expressive debe estar vacío.

Ahora añadimos las dependencias para GraphQL

$ cd graphql-expressive
$ composer require webonyx/graphql-php

Ahora vamos con el código, lo primero que haremos será configurar un middleware para procesar correctamente las peticiones en JSON, editamos el archivo config/pipeline.php agregando estas dos líneas:

use Zend\Expressive\Helper\BodyParams\BodyParamsMiddleware;
...
$app->pipe(BodyParamsMiddleware::class);

Primero vamos a crear una clase de registro para los tipos asociados a nuestras consultas, de esta forma nos será más fácil y práctico dividir por objetos las diferentes consultas a nuestra API, yo he decidido ubicarlo en src/App/src/GraphQL con el nombre de TypeRegistry.php y el siguiente contenido:

namespace App\GraphQL;

use GraphQL\Type\Definition\ObjectType;

class TypeRegistry
{
    public function get(string $name): ObjectType
    {
        $className = self::getClassName($name);
        return new $className($this);
    }

    protected static function getClassName(string $name): string
    {
        return __NAMESPACE__ . '\\Type\\' . ucfirst($name) . 'Type';
    }
}

No entraré en mucho detalle con los tipos pero del código anterior se deduce que estarán ubicados en el namespace App\GraphQL\Type y que la forma de llamarlos será invocando la función get del registro, si el tipo se llama BlogStoryType la llamada sería get('blogStory'), esta implementación es libre, cada uno la puede hacer cómo mejor le parezca.

Una vez creado el registro y antes de crear la ruta necesitamos especificar el manejador, que lo ubicaremos en src/App/src/Handler con el nombre de GraphQLHandler.php y el siguiente contenido:

namespace App\Handler;

use App\GraphQL\TypeRegistry;
use GraphQL\Server\StandardServer;
use GraphQL\Type\Schema;
use GraphQL\Type\SchemaConfig;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Zend\Diactoros\Response\JsonResponse;

class GraphQLHandler implements RequestHandlerInterface
{
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $typeRegistry = new TypeRegistry();
        $config = SchemaConfig::create()
            ->setQuery($typeRegistry->get('query'));
        $schema = new Schema($config);
        $server = new StandardServer([
            'schema' => $schema,
            'queryBatching' => true,
            'debug' => true
        ]);
        $response = $server->executePsrRequest($request);
        return new JsonResponse($response);
    }
}

Ahora configuramos la ruta en la que recibiremos las peticiones, en mi caso graphql (puede ser cualquiera) y solo admito peticiones por POST, esto ya es a gusto de cada uno.

$app->post('/graphql', App\Handler\GraphQLHandler::class, 'graphql');

Veamos un ejemplo

src/App/src/GraphQL/Type/UserType.php

namespace App\GraphQL\Type;

use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;

class UserType extends ObjectType
{
    public function __construct()
    {
        parent::__construct([
            'fields' => [
                'id' => Type::int(),
                'name' => Type::string()
            ]
        ]);
    }
}

src/App/src/GraphQL/Type/BlogStoryType.php

namespace App\GraphQL\Type;

use App\GraphQL\TypeRegistry;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;

class BlogStoryType extends ObjectType
{
    public function __construct(TypeRegistry $types)
    {
        parent::__construct([
            'fields' => [
                'author' => [
                    'type' => $types->get('user'),
                    'resolve' => function (array $blogStory) {
                        $users = [
                            1 => [
                                'id' => 1,
                                'name' => 'Smith'
                            ],
                            2 => [
                                'id' => 2,
                                'name' => 'Anderson'
                            ]
                        ];
                        return $users[$blogStory['authorId']];
                    }
                ],
                'title' => Type::string()
            ]
        ]);
    }
}

src/App/src/GraphQL/Type/QueryType.php

namespace App\GraphQL\Type;

use App\GraphQL\TypeRegistry;
use GraphQL\Type\Definition\ObjectType;

class QueryType extends ObjectType
{
    public function __construct(TypeRegistry $types)
    {
        parent::__construct([
            'fields' => [
                'lastStory' => [
                    'type' => $types->get('blogStory'),
                    'resolve' => function () {
                        return [
                            'id' => 1,
                            'title' => 'Example blog post',
                            'authorId' => 1
                        ];
                    }
                ]
            ]
        ]);
    }
}

Y lo podemos ejecutar por dos vías, o por un script

$query = <<<'QL'
{
  lastStory {
    title
    author {
      name
    }
  }
}
QL;

$chObj = curl_init();
curl_setopt($chObj, CURLOPT_URL, 'http://graphql.lcl/graphql');
curl_setopt($chObj, CURLOPT_RETURNTRANSFER, true);
curl_setopt($chObj, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($chObj, CURLOPT_HEADER, true);
curl_setopt($chObj, CURLOPT_VERBOSE, true);
curl_setopt($chObj, CURLOPT_POSTFIELDS, $query);
curl_setopt($chObj, CURLOPT_HTTPHEADER,
    [
        'User-Agent: PHP Script',
        'Content-Type: application/graphql;charset=utf-8'
    ]
);

$response = curl_exec($chObj);
echo $response;

O utilizando la extensión para Firefox o Chrome de Altair GraphQL Client

Es importante saber el content type con el que vamos a hacer nuestras consultas, este método soporta ambos: application/graphql y application/json, la extensión para el navegador utiliza application/json y el ejemplo que os he puesto con curl utiliza application/graphql.

Personalizar las tablas users y password_resets en Laravel 5.6

2018-04-21T23:32:00.001+02:00

La autenticación en Laravel es un proceso muy sencillo, pero de tan sencillo personalizarlo tiene sus detalles, en este post veremos como personalizar, en parte, las tablas de usuarios y reinicio de contraseñas.

Según lo estricto que seas con la estructura de tu base de datos y el formato que hayas elegido seguir puede que los valores de los campos y las tablas por defecto de Laravel no sean de tu agrado, como es mi caso, por ejemplo: Laravel prefiere minúsculas y plurales para los nombres de las tablas, yo utilizo UpperCamelCase y singular. Para los nombres de los campos Laravel utiliza guión bajo (underscore) y minúsculas, yo prefiero lowerCamelCase, con lo cual, necesito renombrar los siguientes campos de estas tablas:

remember_token - rememberToken
created_at - createdAt
updated_at - updatedAt
id - userId

Y renombrar las tablas:

users - User
password_resets - PasswordReset

Si utilizas las migraciones de Laravel tienes que cambiar los nombres de las tablas y los campos en los archivos database/migrations/2016_01_01_000000_create_users_table.php y database/migrations/2016_01_01_100000_create_password_resets_table.php. Yo en mi caso no puedo utilizar migraciones porque uso SQL Server 2017 y mi tabla de usuarios es un nodo (graph database) actualmente no soportado por Eloquent.

Superado el paso de las migraciones vayamos al código para personalizar la tabla de usuarios, necesitamos modificar estos dos archivos:

Personalizar la tabla password_resets es un poco más complicado pero no imposible, los pasos para hacerlo están en el siguiente commit de github.

Espero que os ayude.

Instalar PHP APCu en CentOS 6.9

2018-02-20T09:00:00.000+01:00

Utilizando los repositorios de remi podemos instalar muy fácilmente APCu siguiendo este comando

sudo yum install php-pecl-apcu

Si os da este error con reiniciar apache o nginx es suficiente.

Installing : php-pecl-apcu-bc-1.0.3-6.el6.remi.7.1.x86_64 
PHP Warning:  PHP Startup: Unable to load dynamic library '/usr/lib64/php/modules/apc.so' - /usr/lib64/php/modules/apc.so: undefined symbol: zif_apcu_store in Unknown on line 0

Instalar última versión de Nodejs en CentOS 7 con yum

2018-02-19T09:00:00.000+01:00

Node proporciona en su web un rpm con los repositorios para instalar sus últimas versiones en CentOs.

cd /tmp
sudo curl --silent --location https://rpm.nodesource.com/setup_9.x | sudo bash -
sudo yum install -y nodejs gcc-c++ make
node -v
 v9.5.0
npm -v
 5.6.0

Instalar última versión de Git en CentOS 7 con yum

2018-02-16T08:42:00.000+01:00

Gracias a los repositorios del proyecto IUS podemos tener las últimas versiones de Git instaladas con yum en nuestro CentOs, es válido para las versiones 6 y 7 de esta distribución de linux.

sudo yum install https://$(rpm -E '%{?centos:centos}%{!?centos:rhel}%{rhel}').iuscommunity.org/ius-release.rpm
sudo yum install yum-plugin-replace
sudo yum replace git --replace-with git2u
git --version
--- git version 2.16.1

PHP en Google compute engine + cloud sql

2018-01-22T22:47:00.000+01:00

Hoy en día los servicios en la nube son una clara alternativa a la hora de alojar un sitio web, ya no es necesario un servidor dedicado con las prestaciones y herramientas que ofrecen Google, Amazon o Azure.

En el caso de Google existen alternativas más sencillas para alojar un sitio web que las de utilizar compute engine (una maquina virtual), me refiero a app engine, pero a mi parecer se pierde mucho control sobre las prestaciones que queramos tener. En este post pienso hablar de como instalar nginx con soporte para http2 y php 7.2 en una maquina virtual con CentOS 7, además de enseñar a configurarlo para utilizar una base de datos MySQL 5.7 almacenada en el servicio cloud SQL de Google.

A la hora de sar de alta estos servicios es muy recomendable que esten en la misma zona geográfica, tanto la maquina virtual como la instancia de MySQL.

Una vez creada nuestra instancia de maquina virtual instalaremos nginx y comprobaremos su configuración con:

nginx -V
nginx -t

Ahora sólo nos queda ejecutarlo como servicio

# arrancamos el servicio
# si ejecutas sudo systemctl start nginx -> nginx: [emerg] open() "/var/run/nginx.pid" failed (13: Permission denied)
sudo service nginx start 
# lo habilitamos para que se inicie al iniciar la máquina
sudo systemctl enable nginx
# editamos el archivo de configuracion para permitir la conexión con la ip de la instancia
sudo vim /etc/nginx/conf.d/default.conf
# reinciamos el servicio ya es posible utilizar systemctl 
# sudo systemctl restart nginx

Instalamos php y modificar en el archivo /etc/php-fpm.d/www.conf el usuario que ejecutará el servicio php-fpm para que sea nginx, al igual que el grupo.

sudo systemctl enable php-fpm
sudo systemctl start php-fpm
sudo chown -R nginx:nginx /var/lib/php
# comprobamos que esté habilitada la conexión con mysql en selinux
getsebool -a | grep httpd_can_network
# si no lo está la habilitamos para evitar este error PHP Warning:  mysqli_connect(): (HY000/2002): Permission denied
sudo setsebool -P httpd_can_network_connect_db 1
# si tenemos alguna carpeta en la cual tendriamos que escribir, habilitamos los permisos en selinux también
sudo chcon -R -t httpd_sys_rw_content_t folder-name

Así tenemos configurada nuestra instancia, vamos a configurar ahora la conexión con nuestra base de datos.

Lo primero es hacer nuestra ip asignada estática (https://console.cloud.google.com/networking/addresses/list?project=xxxxxx), por defecto es dinámica y no queremos esto a la hora de conectarla a un servicio de Cloud SQL.

Y por último habilitar esta ip para que se pueda conectar nuestra maquina virtual con PHP.

Nota: es posible configurar usuarios para acceder a nuestra base de datos y que no sean root pero estos usuarios tendrán permisos para acceder a todas las bases de datos en esa instancia, no se pueden personalizar estos permisos ni configurarlos desde ningún cliente remoto.

Microsoft ODBC 17 + SQL server driver 5.2.0 RC1 previews

2018-01-22T17:00:00.000+01:00

Microsoft está apostando fuerte con SQL Server en Linux, aún le falta un IDE potente como SSMS pero el servidor y la conectividad con lenguajes como PHP está servida, ya no es necesario tener que compilar de cero PHP para tener paquetes que no están en producción, sobre todo de Microsoft, todo gracias a la ayuda del rempositorio de Remi y las contibuciones en github de la propia Microsoft.

Con esta base previa, hoy, me centraré en instalar el nuevo driver ODBC con soporte para Always Encripted, el driver de PHP 5.2 y todo con la última versión en el mercado de PHP, la 7.2. Los pasos a seguir son estos:

sudo yum -y install epel-release wget yum-utils
sudo wget http://rpms.famillecollet.com/enterprise/remi-release-7.rpm
sudo rpm -Uvh remi-release-7*.rpm
sudo yum-config-manager --enable remi-php72
sudo yum install -y unixODBC-devel autoconf
sudo curl https://packages.microsoft.com/config/rhel/7/prod.repo > /etc/yum.repos.d/mssql-release.repo

Ahora necesitamos instalar la última versión estable paa que resuelva las dependencias necesarias, luego la desisntalamos

sudo ACCEPT_EULA=Y yum install -y msodbcsql mssql-tools
sudo yum remove -y msodbcsql mssql-tools

Ahora es el momento de instalar la versión previa del driver ODBC, los enlaces de descarga pueden variar y cuando sea una versión estable estos pasos ya no serán necesarios

sudo wget https://github.com/Microsoft/msphpsql/raw/master/ODBC%2017%20binaries%20preview/Red%20Hat%207/msodbcsql-17.0.0.5-1.x86_64.rpm
sudo wget https://github.com/Microsoft/msphpsql/blob/master/ODBC%2017%20binaries%20preview/Red%20Hat%207/mssql-tools-17.0.0.5-1.x86_64.rpm
sudo ACCEPT_EULA=Y yum localinstall -y msodbcsql-17.0.0.5-1.x86_64.rpm
sudo ACCEPT_EULA=Y yum localinstall -y mssql-tools-17.0.0.5-1.x86_64.rpm
sudo ln -sfnv /opt/mssql-tools/bin/* /usr/bin

Es posible que mssql-tools de errores y no se pueda instalar, no afecta a la instalación de PHP

Ahora instalamos PHP 7.2 y el driver para PHP en la versión 5.2 RC1

sudo yum install -y php-fpm php-cli php-common php-pear
sudo yum --enablerepo=remi-php72-test -y install php-sqlsrv
sudo yum clean all

Tengo contenedores docker con estos pasos, para las versiones estables y en desarrollo, aunque incluyen muchas librerías de PHP que tal vez no necesitéis.

Nota: aquí solo instalo sqlsrv no la variante de PDO pero sólo sería agregarla al comando de yum install.

CentOS 7 soporte para HTTP2 con NginX

2018-01-21T22:23:00.000+01:00

Esta entrada sigue un poco la línea del artículo en el que comentaba que para dar soporte a HTTP/2 para los usuarios de Google Chrome tendríamos que utilizar algún repositorio ya compilado o compilar nosotros mismos NginX con las últimas versiones de OpenSSL.

En el post citado elegí la primera opción, pero encontrarme con un repositorio fiable, con un buen mantenimiento, actualizaciones y las últimas versiones de OpenSSL ha sido difícil, es por ello que decidí compilar mi propia versión de NginX con las últimas versiones de OpenSSL en CentOS 7, y estos son los pasos:

sudo yum -y groupinstall 'Development Tools'
sudo yum -y install epel-release \
                   wget \
                   openssl \
                   openssl-devel \
                   zlib-devel \
                   pcre-devel \
                   redhat-lsb-core
sudo yum clean all 
sudo useradd builder 
sudo mkdir -p /opt/lib
sudo wget https://www.openssl.org/source/openssl-1.1.0g.tar.gz -O /opt/lib/openssl-1.1.0g.tar.gz
sudo tar -zxvf /opt/lib/open* -C /opt/lib
sudo rpm -ivh http://nginx.org/packages/mainline/centos/7/SRPMS/nginx-1.13.8-1.el7_4.ngx.src.rpm
sudo sed -i "s|--with-http_ssl_module|--with-http_ssl_module --with-openssl=/opt/lib/openssl-1.1.0g|g" /root/rpmbuild/SPECS/nginx.spec
sudo rpmbuild -ba --clean /root/rpmbuild/SPECS/nginx.spec
sudo rpm -Uvh --force /root/rpmbuild/RPMS/x86_64/nginx-1.13.8-1.el7_4.ngx.x86_64.rpm

En concreto las versiones son la últimas hasta la fecha (openssl 1.1.0g y nginx 1.13.8), e incluye paquetes como redhat-lsb-core que su ausencia en las últimas versiones generaba el error lsb_release: command not found al ejecutar el penúltimo paso.

Estaría también disponible un contenedor en docker con estos cambios y que intento mantener actualizado.

Instalación y configuración de subversion en Windows

2017-07-26T11:21:00.001+02:00

Así se instalaba y configuraba Collbanet Subversion Edge en 2011.

¿Qué es Subversion?

Antes de saber que es Subversion debemos tener en cuenta algunos conceptos previos cómo el de versión, control de versiones y sistemas de control de revisiones.

Una versión, revisión o edición de un producto, es el estado en el que se encuentra dicho producto en un momento dado de su desarrollo o modificación. Se llama control de versiones a la gestión de los diversos cambios que se realizan sobre los elementos de algún producto o una configuración del mismo. Los sistemas de control de versiones facilitan la administración de las distintas versiones de cada producto desarrollado, así como las posibles especializaciones realizadas.

Un Sistema de Control de Revisiones (Revision Control System - RCS) es una implementación de software para el control de versiones que automatiza las tareas de guardar, recuperar, registrar, identificar y mezclar versiones de archivos.

Resumiendo, Subversion no es más que un sistema de control de versiones diseñado específicamente para reemplazar al popular CVS.

Instalación de Subversion en Windows

Existen multitud de instaladores de subversion, algunos más complicados que otros. Tenemos que tener en cuenta que un sistema de control de versiones requiere de 3 elementos fundamentales para funcionar: el propio sistema de control de revisiones, un servidor web para poder servir los archivos y un visor para gestionar los repositorios.

En este manual utilizaremos el más completo y sencillo de instalar a mi modo de ver, este software es el Collabnet Subversion Edge e instala en un solo clic subversión, Apache y ViewVC.

Aunque esta es la parte que nos va a servir los archivos (la parte servidor) por tanto necesitamos algún programa en nuestros ordenadores para gestionar estos repositorios de manera sencilla, el programa elegido es el Tortoise SVN.

Ambas instalaciones son las típicas de siguiente siguiente, no es necesario configurar nada específico, lo único a tener en cuenta es del lado del servidor que el puerto 80 esté libre para el apache, en caso de no estarlo debemos modificar este puerto una vez instalado el Collabnet Subversion Edge en su menú de Administración:

Nota: la primera vez que instalamos subversion este no se inicia por defecto debemos iniciarlo manualmente en la pantalla de status (ver imagen siguiente) si nos da error de puerto debemos cambiarlo en la imagen anterior y además debemos marcar el último check de esta página para iniciarlo siempre automáticamente.

Algunas notas adicionales: El Tortoise SVN se integra con el explorador de Windows por lo que es más que probable que necesitemos reiniciar el equipo. También es importante recordar la contraseña del usuario admin (en el proceso de instalación nos pide crear una) en el Collabnet Subversion Edge aunque luego la podamos cambiar.

Creación de repositorios

Aclaremos algunos conceptos primero, un repositorio se crea en el servidor y los usuarios al conectarse a este se descargan o suben archivos al mismos, un repositorio no está en local, en local sólo tenemos una copia (puede que no sea actualizada) del repositorio almacenado en el servidor.

Una vez aclarado esto crearemos un repositorio en nuestro servidor:

El único paso que tenemos que hacer es darle un nombre, más nada. Sencillo ¿verdad? Para ver nuestro repositorio nos desplazamos hasta el listado:

De este listado con lo que tenemos que quedarnos es con la url del repositorio (recuadro rojo) para poder acceder remotamente al mismo desde nuestro ordenador.

Creación de usuarios en Subversion

Aunque podemos acceder remotamente con el usuario admin a cualquier repositorio es muy recomendable crear usuarios remotos para estos (también para cada repositorio se puede denegar el acceso a unos usuarios y permitirlo a otros). Debemos tener en cuenta que los usuarios creados en la siguiente pantalla tienen acceso a todos los repositorios por defecto, para editar estos accesos en cada uno debemos ir a cada repositorio y modificar las reglas de acceso.

Para crear un usuario solo debemos rellenar los datos y elegir el rol del mismo, por defecto siempre será un usuario normal:

Recordad que si no editamos las reglas de acceso de nuestros repositorios todos los usuarios que creemos aquí van a tener acceso a los mismos.

Bien, hasta ahora todo es bastante sencillo, y la siguiente parte también, aunque tenemos que hacer algunos pequeños trucos para trabajar con proyectos que ya existen.

Actualizar un repositorio para un proyecto con archivos ya creados

Este pequeño truco se debe a una limitación por parte de Subversion que impide que vinculemos un directorio local a un repositorio si este directorio no está vacío. La pregunta sería ¿entonces como creo un repositorio para archivos que ya tengo? ¿Cómo los incluyo en este repositorio nuevo?

El truco es muy sencillo y os describo los pasos a seguir:

Primero debemos subir los archivos al repositorio nuevo que hemos creado
Luego debemos crear una carpeta local al mismo nivel que la que contiene los archivos subidos.
Después vinculamos esta carpeta nueva con el repositorio (con ello tendría una copia exacta de todos los archivos subidos)
Finalmente borramos la carpeta original y renombramos la nueva con el nombre original.

De esta forma ya tenemos un directorio local vinculado a un repositorio con los archivos antiguos.

Importante: esto no es necesario para proyectos nuevos en los cuales no hayamos creado ningún archivo aún. Veamos estos pasos uno a uno.

Subir archivos antiguos a un repositorio nuevo

Para importar archivos a nuestro repositorio lo podemos hacer de una manera muy simple con Tortoise SVN, como os dije anteriormente este programa se integra perfectamente con el explorador de Windows por lo que el único paso necesario es hacer clic derecho sobre la carpeta, elegir Tortoise SVN y luego importar:

En la siguiente ventana introducimos la url del repositorio (sin usuario) y en caso de que no la tengamos cacheada en nuestro ordenador nos pedirá el usuario y la clave al pulsar Aceptar, si todo está correcto se iniciará el proceso y tendremos ya subidos los archivos a nuestro repositorio.

Nota: Este paso solo sube los archivos (los importa) a nuestro repositorio pero no vincula esta carpeta con el mismo que es lo que necesitamos para subir las modificaciones o descargarnos revisiones antiguas.

Vincular una carpeta local a un repositorio

Este paso si deben seguirlo todos los que quieran vincular carpetas locales a un repositorio y recordar que la carpeta local debe estar vacía y con permisos de escritura.

Igualmente que en el paso anterior para obtener el código de un repositorio y vincularlo a nuestra carpeta local lo único que debemos hacer es clic derecho y pulsar la opción Obtener:

En el dialogo siguiente seleccionamos el repositorio (nos pedirá igualmente el usuario y la contraseña al pulsar aceptar si el mismo no está cacheado) y podemos descargarnos cualquiera de las revisiones existentes, para la primera vez es aconsejable descargarse la HEAD (la última):

De esta forma ya tenemos vinculado nuestro directorio con un repositorio, si todo ha ido bien aparte de descargarnos los archivos al pulsar clic derecho en la carpeta veremos cómo cambian las opciones de la carpeta:

Estas dos opciones son las básicas de Subversion, SVN Actualizar nos permite obtener los archivos del servidor mientras que SVN Confirmar nos permite importar al repositorio nuestras modificaciones que pueden estar acompañadas o no por algún mensaje identificativo de la operación o los cambios realizados.

Nota adicional: Podemos acceder y confirmar cambios en repositorios de unidades de red siempre y cuando estos se hayan creado desde la máquina real, o sea si tú tienes en un servidor un directorio vinculado a un repositorio y accedes a él desde tú máquina puedes confirmar los cambios desde allí sin necesidad de hacerlo desde la propia máquina.

Recomendaciones para SQL Server con Dynamics NAV

2017-07-26T11:12:00.000+02:00

Max Server Memory

MAX_SERVER_MEMORY = TOTAL_SERVER_MEMORY - [OS/Apps Memory] - [Threads * Thread Size]

TOTAL_SERVER_MEMORY = 24GB

OS/Apps Memory = 4 GB (systems with > 16GB of RAM)

Threads = 576

Thread Size = 2MB (x64)

Recomendado MAX_SERVER_MEMORY = 18 GB

Auto - Create Statistics

Se recomienda fuertemente activar "Auto Create Statistics" ya que es una de las formas que utiliza el propio SQL Server para mejorar el rendimiento. El coste para ejecutar esta opción es mínimo en comparación con el problema de rendimiento que puede experimentar si una estadística necesaria falta y SQL Server no la puede crear. Las estadísticas son un factor muy importante en el plan de consultas eficientes que viene con SQL Server.

Auto - Update Statistics

Se recomienda fuertemente activar "Auto Update Statistics" ya que es una de las formas que utiliza el propio SQL Server para mejorar el rendimiento. El coste para ejecutar esta opción es mínimo en comparación con el problema de rendimiento que puede experimentar si una estadística no está actualizada y SQL Server la utiliza para compilar la consulta y crear el plan de ejecución. Esto es muy importante con C/AL FINDFIRST, FINDLAST, FIND('-'), FIND('+'), y FINDSET para [Entrada No.] porque si la estadística en [N º Entrada] está fuera de fecha llevará a SQL Server más tiempo para encontrar el primer y último valor, bloqueando el recurso durante mucho tiempo y causando un impacto negativo en la concurrencia del sistema y, posiblemente, resultando en tiempos muertos de bloqueo (Lock Time Outs).

Auto-Grow

Auto-Growths (Auto-crecimientos) de la base de datos o del registro de transacciones en entornos de producción puede degradar el rendimiento pues todas las transacciones deben hacer cola y esperar al SQL Server para hacer crecer el archivo de registro o de datos antes de que pueda comenzar a procesar las transacciones de nuevo. Esto puede crear un cuello de botella. Recomendamos fuertemente el crecimiento de los datos y del archivo de registro durante las horas pico entre un 10 a 25% del tamaño actual. No recomendamos desactivar Auto-Grow pues en casos de emergencia es mejor tenerlo activado que quedarse sin espacio y poner la base de datos fuera de servicio.

Trace Flag 4119

Si está ejecutando SQL Server 2005, le recomendamos que active el indicador de traza 4119 por razones de rendimiento. (Esto no es necesario en SQL 2008)

TempDB

El número de archivos de datos de TempDB debe ser igual al número de núcleos de CPU utilizada por SQL Server, hasta un máximo de 8. Esto evita los cuellos de botella en el proceso de asignación de página SGAM (Shared Global Allocation Map) cuando los nuevos objetos temporales son creados. Los archivos de TempDB deben estar en una unidad separada de los datos y los archivos de registro.

Esta recomendación viene dada ya que cada objeto temporal que se crea en TempDB necesita páginas asignadas para ello. Estas páginas deben ser asignados a través de páginas SGAM y sólo hay una página SGAM por archivo de datos (no realmente, pero lo suficientemente cerca). Así que si tienes un solo archivo de datos y se está creando una gran cantidad de objetos temporales, como es posible con SSRS y RCSI (u otras bases de datos en el servidor, ya que todos utilizan la misma TempDB) puede crearse un cuello de botella pues está tratando de manejar las asignaciones de muchas peticiones al mismo tiempo. Es por eso que existe la recomendación de crear un archivo de datos TempDB por núcleo de la CPU o hilos activos para aliviar la posibilidad de un cuello de botella en la asignación. Esto es raro pero puede suceder.

NOTA: Cada archivo de TempDB no necesita estar en su propia unidad de disco, sólo tienen que estar separados de todos los datos de SQL y archivos de registro.

Disk Alignment

La alineación del disco puede tener un impacto significativo en el rendimiento del disco como un bloque puede abarcar dos discos físicos. Puesto que la configuración adecuada puede variar mucho según el fabricante, consulte a su fabricante de hardware para verificar la alineación del disco y la configuración adecuada. La asignación o el tamaño de banda debe ser> = 8k para evitar páginas rasgadas se recomienda 64k para que coincida con el tamaño de la extensión de SQL Server (8 - 8K páginas).

Para comprobar la alineación del disco:

Click "Start" - "Run" and type MSINFO32
Click "Components" - "Storage" - "Disks"
Look at the value for "Partition Starting Offset" for the drive you wish to check

Si el resultado de dividir el valor de Partition Starting Offset por (64 * 1024) es un número entero entonces los discos están alineados en esa unidad, si por el contrario es un número decimal entonces los discos no están alineados.

NOTA: En todas las unidades formateadas con Windows Server 2008 o posteriores se alinearán automáticamente los discos.

Read Committed Snapshot Isolation (RCSI)

Con el lanzamiento de SQL Server 2005, un nuevo nivel de aislamiento se introdujo llamado Read Committed Snapshot. Este nivel de aislamiento imita el "Nivel 1" de lectura confirmada, que es el predeterminado de SQL Server, pero permite una mayor concurrencia y menos bloqueo ya que utiliza un principio de versiones en los registros bloqueados. Los procesos de lectura y escritura reciben diferentes "versiones" del registro para que no bloquee cada vez que mantiene la coherencia transaccional. Estas versiones de filas se ayudan del almacén de versiones que se mantiene en TempDB. Desde la perspectiva de Microsoft Dynamics NAV no es muy útil como NAV envía sugerencias de nivel de aislamiento con la mayoría de los estados que anularán RCSI, sino que tendrá un beneficio cuando las aplicaciones externas accedan a los registros en la base de datos de producción NAV tales como informes, opiniones, y aplicaciones secundarias . (SSRS, los procesos ETL, etc.)

ALTER DATABASE MyDatabase SET SINGLE_USER WITH ROLLBACK_INMEDIATE

ALTER DATABASE DatabaseName

SET READ_COMMITTED_SNAPSHOT ON

GO

NOTA: TempDB debe ser configurado según las recomendaciones o la asignación de páginas pueden producir cuellos de botella.

Max Degree of Parallelism

Cuando SQL Server se ejecuta en un equipo con más de un microprocesador o CPU, detecta el mejor grado de paralelismo, es decir, el número de procesadores que se emplea para ejecutar una única instrucción en cada ejecución de planes en paralelo. Puede utilizar la opción max degree of parallelism para limitar el número de procesadores utilizados en la ejecución de planes paralelos. Para que el servidor pueda determinar el Grado máximo de paralelismo, establezca esta opción en 0, que es el valor predeterminado. Si se establece el grado máximo de paralelismo en 0, SQL Server puede utilizar todos los procesadores disponibles hasta un número de 64. Para suprimir la generación del plan paralelo, establezca max degree of parallelism en 1.

Microsoft Dynamics NAV se comunica con el servidor SQL a través de ODBC. El C / AL se convierte en simples declaraciones TSQL a través de la librería NDBCS.DLL. Estas declaraciones son muy simples Select, Update, Insert y Delete de SQL y no requieren de la ejecución en paralelo en SQL Server. Esto no impide que el compilador a veces trate de utilizar la ejecución en paralelo en la planificación de las consultas y esto, a veces, puede afectar negativamente al rendimiento. Es por eso que se recomienda establecer el grado máximo de paralelismo en SQL Server en 1 para evitarlo.

sp_configure 'max degree of parallelism', 1
RECONFIGURE
GO

NOTA: Si está ejecutando los trabajos de mantenimiento de SQL Server Enterprise Edition estos son multi-hilo, pero si usted pone como grado máximo de paralelismo 1 estos se ejecutarán en un solo subproceso. Le recomendamos que en el trabajo de mantenimiento regrese el grado máximo de paralelismo a 0 y al ejecutar el trabajo de mantenimiento volver a 1. Esto se puede hacer con el código de TSQL dentro del propio trabajo de mantenimiento.

Dynamics NAV Default Isolation Level

Con el lanzamiento de Microsoft Dynamics NAV 5.00 SP1 (Build 30482 / KB 979135) y posteriores tenemos la opción de cambiar el nivel de aislamiento predeterminado de NAV de SERIALIZABLE a REPEATABLEREAD.

SERIALIZABLE: Este es el nivel de aislamiento más restrictivo. Cuando se utiliza, los valores fantasmas no pueden ocurrir pues impide que otros usuarios actualicen o inserten filas en el conjunto de datos hasta que la transacción se complete.

REPEATABLEREAD: Cuando se utiliza, las lecturas ‘sucias’ y no repetibles no pueden ocurrir. Esto significa que los bloqueos se colocarán en todos los datos que se utilizan en una consulta y otra transacción no puede actualizarlos. En resumen SERIALIZABLE es más restrictiva y bloquea más registros que REPEATABLEREAD que puede causar más tiempos de espera de bloqueos y desbloqueos. REPEATABLEREAD es menos restrictiva y permite una mayor concurrencia en general.

Configuración por defecto del nivel de aislamiento en NAV de SERIALIZABLE a REPEATABLEREAD

UPDATE [$ndo$dbproperty] SET diagnostics = 4194304

Microsoft Dynamics NAV "Lock Timeout"

Este ajuste significa básicamente que si un usuario intenta acceder a un recurso y está bloqueado por otro usuario espere los segundos que usted ha especificado y vuelva a intentarlo antes de emitir un mensaje de error. Le recomendamos que esta opción no se utilice en absoluto o que se establezca entre unos 10 a 20 segundos, un valor muy alto para el bloqueo estático de tiempo de espera puede causar problemas. Por lo general, cuando un cliente tiene un gran valor que para esto es porque hay un problema de rendimiento subyacente. Esto realmente depende de cada configuración y puede ser mayor si hay circunstancias específicas.

Para cambiar el valor por defecto en Microsoft Dynamics NAV, click File, click Database, y luego click Alter para abrir la ventana de Alter Database. Click en la pestaña Advanced y marque o desmarque la casilla de Lock timeout field.

Microsoft Dynamics NAV "Always Rowlock"

Microsoft Dynamics NAV siempre bloquea las filas por una compatibilidad con sistemas de 32 bits y sobre SQL Server 2000. En el 99% de los casos en SQL Server 2005 y posteriores esto se puede desactivar liberando la memoria de bloqueo que SQL puede utilizar para otros fines sin ninguna pérdida de rendimiento.

NOTA: En algunas pruebas de rendimiento sin tener esta opción habilitada la concurrencia y el rendimiento aumentaron.

Maintenance Jobs

Statistics

Incluso con la opción de actualizar estadísticas automáticamente activada se recomienda ejecutar un trabajo de mantenimiento periódico para actualizar las mismas. Esto se debe a que la actualización automática de estadísticas sólo se activa cuando el 5% de los datos de esta estadística ha cambiado y en las tablas como Value Entry, Item Ledger Entry, G/L Entry, y aquellas que pueden tener entre los 10 de millones de registros un pequeño porcentaje de los datos en una estadística dada como [N º de entrada] puede cambiar con un efecto significativo sobre la distribución general de los datos de esta estadística causando planes de ejecución de consultas ineficientes mucho antes de que el umbral del 5% se alcance provocando como resultado un rendimiento degradado. Se recomienda el uso de sp_updatestats para realizar esta tarea, ya que sólo se actualizarán las estadísticas donde los datos se han cambiado. Le recomendamos la creación de un trabajo de SQL que se ejecute diaria o semanal mente (dependiendo del volumen de transacciones) en las horas pico para actualizar todas las estadísticas donde los datos han cambiado.

NOTA: No use "FULLSCAN", ya que es una pérdida de tiempo pues se sobrescribirá en el momento en que la estadística se auto actualiza.

USE AdventureWorks2008R2;

GO

EXEC sp_updatestats

Index defragmentation

Los índices se fragmentan al igual que los discos duros y pueden tener un impacto negativo en el rendimiento general. Se recomienda utilizar la siguiente secuencia de comandos que reconstruye y reorganiza las funciones de desfragmentación de índices. Le recomendamos la creación de un trabajo de SQL que se ejecute diaria o semanalmente (dependiendo del volumen de transacciones) durante las horas pico para actualizar todos los índices.

Instant File initialization

En SQL Server 2005 y versiones posteriores, los archivos de datos se pueden inicializar de forma instantánea, lo que permite la ejecución rápida de la base de datos o grupo de archivos de restauración. La inicialización instantánea de archivos utiliza espacio de disco sin necesidad de rellenar ese espacio con ceros. En cambio, el contenido del disco se sobrescribe según los nuevos datos se escriben en los archivos. El registro del archivo de inicialización aún requiere rellenarse con ceros pero esto sucede en paralelo con la transferencia de los datos de la copia de seguridad. El siguiente paso de la restauración no se iniciará hasta que todos los datos han sido transferidos y todo el registro se ha inicializado.

Para utilizar la inicialización instantánea de archivos se debe ejecutar el servicio MSSQLSERVER en una cuenta de Windows y asignar el privilegio especial de Windows SE_MANAGE_VOLUME_NAME a dicha cuenta. Este privilegio se asigna al grupo de administradores de Windows por defecto. Si tiene derechos de administrador del sistema puede asignar este privilegio mediante la adición de la cuenta de Windows a la política de seguridad para Realizar tareas de mantenimiento del volumen.

"Page Verify" - Checksum vs. Torn Page Detection

Se recomienda para verificar la paginación de la base de datos (Database Page Verify) el uso de la opción suma de comprobación (Checksum) pues es mucho más robusto en la detección de la corrupción de base de datos física.

ALTER DATABASE DatabaseName

SET PAGE_VERIFY CHECKSUM;

GO

Lock Pages in Memory

Le recomendamos activar la opción para bloquear páginas en memoria y de esta forma el sistema operativo no interfiere en la página de SQL Server. Sin embargo en 64 bits sólo tendrá que conceder el derecho de bloqueo de páginas en memoria a la cuenta de SQL para que SQL Server pueda utilizar esta característica.

Actualizando columnas identity en SQL Server

2017-07-13T11:53:00.000+02:00

Aclaremos algunos conceptos primero, la propiedad identity puede ser utilizada para generar automáticamente valores clave en una columna, con esto quiere decir que una columna identity no tiene que ser necesariamente una clave primaria, y una clave primaria no tiene que llevar necesariamente la propiedad identity.

Una columna identity no puede ser modificada (Cannot update identity column), la opción identity_insert sólo permite insertar valores en este tipo de columnas, pero nunca actualizarlos. ¿cómo actualizarlos entonces?

Pongámonos en el peor de los casos, una clave primaria de tipo identity a la que hacen referencia foreign keys de otras tablas, si necesitásemos actualizar los valores deberíamos seguir el siguiente procedimiento:

identificar todas las foreign keys que apuntan a la columna identity que deseamos modificar (esto lo podemos hacer con el SSMS escribiendo el nombre de la tabla, seleccionándolo y pulsando Alt + F1, o lo que es lo mismo ejecutando el procedimiento almacenado sp_help)
crear y ejecutar un script para modificar todas esas foreign key de manera que al actualizar la columna de referencia se actualicen las columnas de destino ON UPDATE CASCADE
desde el SSMS quitarle la propiedad identity a la columna
cambiar los valores como una consulta UPDATE normal
habilitar nuevamente la propiedad identity en la columna (automáticamente pondrá el valor de la semilla en 1 más que el máximo valor que hayamos insertado)
modificar las foreign keys si tenían otro valor ON UPDATE

De esta forma podríamos actualizar columnas identity sin perder las referencias en otras tablas.

Recomiendo comprobar luego objetos que tengan SCHEMABINDING que utilicen esta tabla porque el SSMS generalmente suele quitarles esta propiedad sin volverla a poner.

Trabajando con la Surface Pro 4 y accesorios

2017-06-01T00:45:00.001+02:00

Es mi primera entrada en dónde hablo directamente de hardware y me he animado a hacerla por los sentimientos encontrados que he sentido al probar diferentes productos de la gama Surface, en concreto la Surface Pro 4 i7 16 GB 512 SSD, Arc Touch Mouse y el dock.

La Surface es genial, dudaba mucho de su rendimiento pero su procesador i7-6650U de 2 núcleos no tiene nada que envidiarle a un i7-5930K de 6. El comportamiento es excepcional, increíble pensar que en una 'tablet' puedas tener Hyper-V activado con docker y correr un servidor SQL Server sin mayor problema. La única alteración al rendimiento ha sido habilitar mediante PowerShell el modo de energía de alto rendimiento, lo cual dispara el uso del ventilador, muy silencioso, nada comparable con mi anterior sistema de refrigeración líquida Corsair Cooling Hydro Series H110i GT que hace un ruido infernal, sobre todo en verano.

La única pega que tiene son los drivers, hay que estar actualizados a la última versión de Windows 10 para que todo funcione correctamente y aún así el sonido por el mini DisplayPort muchas veces no funciona y hay que reiniciar el driver. Tampoco es aconsejable utilizar las versiones de Windows Insider porque por ejemplo en la build 16199 Windows Hello deja de funcionar.

El lápiz funciona muy bien, reconoce bastante bien lo que escribes, aunque no intentes poner una dirección web porque pone espacios donde no debe. Lo utilizo muy poco.

Los teclados funda de Microsoft para la Surface Pro 4 no están nada mal, son teclados delgados, silenciosos y cómodos, el trackpad muy bueno, lo único que no me gusta es la distribución de las teclas de función que en vez de priorizar las F prioriza funciones como subir y bajar el volumen, esto es normal en los teclados para tablets y no sería mayor problema si no fuera porque todos los teclados de la gama Surface son iguales en ese sentido, gran fallo de Microsoft en no pensar en los programadores.

El Arc Touch Mouse es horrible, no puedes reiniciar el equipo con el encendido porque muchas veces no lo reconoce, ni apagándolo y volviéndolo a encender, tienes que apagar ambos (la Surface y el ratón) y encenderlos. No es nada intuitivo y la documentación está fatal, ¿tanto costaba poner en el manual que plegarlo o estirarlo era encenderlo y apagarlo? Es muy incómodo y el dolor de muñecas me ha obligado a dejar de utilizarlo y guardarlo sólo para viajes que es su cometido real, no es un ratón de uso diario.

La estación de trabajo es otra cosa, acierto total con el tamaño diminuto aunque no tanto con elegir DisplayPort vs HDMI, tiene el mismo problema con los drivers. No necesita instalar nada, la Surface la detecta al instante con todas sus capacidades, puedes tener conectado un monitor externo, la tele y la Surface sin perder resolución en ninguna de las pantallas. Por ponerle una pega, no tiene botón de encendido y apagado.