Por lo que no podrás editar imágenes desde WordPress, como por ejemplo, escalarlas, cambiar la relación de aspecto, etc. También puede ser un problema si estás trabajando con algún builder como Elementor o Divi, ya que no podrás manipular correctamente las imágenes.

El problema es la falta de algunos complementos de PHP que necesitan ser instalados en el servidor, en concreto los paquetes:

• php-gd
• php-imagick

Si estamos trabajando en un servidor online, debemos pedir a nuestro proveedor que instale estos complementos (sería muy raro que no estuviesen instalados, pero cualquiera sabe…).

En el caso de que estés usando una instalación LAMP en local, instala los paquetes desde tu repositorio:

Ubuntu/Debian:

sudo apt install php-gd php-imagick

Arch/Manjaro:

sudo pacman -S php-gd php-imagick

Fedora:

sudo dnf install php-gd php-imagick

Además hay que habilitar la extensión de php-gd desde el archivo de configuración php.ini

Ubuntu/Debian:

sudo nano /etc/php/X.X/apache2/php.ini

Arch/Manjaro:

sudo nano /etc/php/php.ini

Fedora:

sudo nano /etc/php.ini

Y descomentar la línea:

extension=gd

Reiniciar el servidor y listo.

Como ya he comentado en algún post, Manjaro es una de mis distros favoritas. Una Arch Rolling con un entorno de escritorio a prueba de bombas (XFCE).

Sin embargo siempre me muevo en la rama Debian-Ubuntu estable. Uno de los principales motivos es el Stack LAMP (Linux Apache MySQL PHP). Trabajo a menudo con proyectos web en local, casi siempre webs con problemas que tengo que analizar y reparar antes de aplicar los cambios en producción.

La instalación del Stack LAMP en Debian-Ubuntu es bastante sencilla, aquí puedes ver un artículo que escribí hace un par de años y que a día de hoy sigue vigente (lo único que cambia es la versión de PHP).

Pero siempre que he intentado instalar LAMP en otras ramas, como RPM o ARCH, he tenido diversos problemas para hacerlo funcionar, desistiendo y volviendo a mi zona de confort.

Hace poco me lié la manda a la cabeza para instalarlo en Fedora, con excelente resultado (puedes ver el artículo completo).

Pero en Manjaro, aunque tiene algunas similitudes con Fedora, hay que dar algunos pasos más, sobre todo en lo que a configuración de archivos se refiere.

Como siempre, este artículo no solo está hecho para quien lo necesite, si no para mí mismo, tenerlo como referencia para cuando necesite volver a realizar una instalación, sin tener que buscar en varios posts por la Red. Vamos al lío…

Artículo disponible en vídeo

Instalar el servidor web Apache

Abrimos un terminal e instalamos el paquete apache.

sudo pacman -S apache

Una vez instalado, vamos a revisar el archivo de configuración de Apache para comprobar que el módulo unique_id_module está comentado:

Para ello desde el terminal abrimos con el editor nano el archivo:

sudo nano /etc/httpd/conf/httpd.conf

Para buscar en nano puedes usar la combinación Ctrl+W y escribir el texto a buscar:

Esta es la línea que tenemos que mantener comentada (anteponiéndole un #)

Si ya estaba comentada, simplemente podemos salir pulsando Ctrl+X. Para guardar pulsa Ctrl+O.

Ahora podemos habilitar el servicio de apache con el comando:

sudo systemctl enable httpd

E iniciarlo con el comando:

sudo systemctl start httpd

Si necesitamos reiniciar apache porque hayamos hecho algún cambio en la configuración, usamos el comando:

sudo systemctl restart httpd

No obstante, si queremos detener el servicio tecleamos el comando:

sudo systemctl stop httpd

Para comprobar que apache está corriendo, usa el comando:

sudo systemctl status httpd

Debería aparecer active (running):

Para salir del monitor de estado de apache puedes detener con Ctrl+Z.

También podemos abrir un navegador web y dirigirnos a la ruta http://localhost Debería aparecer el índice de apache (que en estos momentos estará vacío):

Hemos terminado con apache, ahora instalaremos el gestor de bases de datos MySQL:

Instalar MySQL (MariaDB)

Nos dirigimos al terminal e instalamos el paquete mysql:

sudo pacman -S mysql

Nos avisará de que existen dos proveedores disponibles para instalar mysql. Vamos a elegir la opción 1) mariadb:

IMPORTANTE: Antes de habilitar el servicio de mysql tenemos que inicializar el directorio de datos de MariaDB. Este paso no es necesario en otras ramas como Debian-Ubuntu o Fedora, pero en Manjaro (o la rama Arch en general) si.

Para ello copiamos/pegamos el siguiente comando:

sudo mysql_install_db --user=mysql --basedir=/usr --datadir=/var/lib/mysql

Ahora podemos habilitar e iniciar mysql:

sudo systemctl enable mysql

sudo systemctl start mysql

Igual que con apache, tenemos los comandos restart y stop para reiniciar o detener mysql.

Vamos a comprobar el estado de mysql con el comando:

sudo systemctl status mysql

Al igual que con apache, debería aparecer Active: active (running):

Detenemos el monitor de estado de mysql con Ctrl+Z.

Ahora toca securizar mysql ya que por defecto únicamente viene con el usuario root sin contraseña:

sudo mysql_secure_installation

Nos pedirá nuestra contraseña de root (de sistema):

Ahora nos pregunta si queremos darle una contraseña a la cuenta root de mysql, respondemos que si (Y):

Change the root password? [Y/n] Y

Respondemos que si (Y).

New password: **********
Re-enter new password: **********

Al resto de preguntas podemos responder que si:

Remove anonymous users? [Y/n] Y

Disallow root login remotely? [Y/n] Y

Remove test database and access to it? [Y/n] Y

Reload privilege tables now? [Y/n] Y

Thanks por using MariaDB!

Entramos en MySQL:

sudo mysql -u root

Vamos a crear un nuevo usuario distinto al de root que será el que asignemos a las bases de datos que creemos posteriormente:

CREATE USER mi_usuario IDENTIFIED BY 'contraseña';

Podemos salir de MySQL con el comando exit:

MariaDB [(none)]> exit;
Bye

Instalación y configuración de PHP

Desde el terminal instalamos la paquetería php y php-apache

sudo pacman -S php php-apache php-gd php-imagick

php-gd y php-imagick son opcionales, pero los necesitaremos para poder manipular imágenes en WordPress.

Como Manjaro es una versión contínua (rolling-release), la versión de PHP será la que haya disponible en el momento que realices la intalación.

A la hora de escribir este artículo, la versión instalada es la 8.0.12.

Puedes comprobar la versión instalada con el comando php -v:

[dani@ThinkPad-T540p ~]$ php -v
PHP 8.0.12 (cli) (built: Oct 20 2021 16:06:03) ( NTS )
Copyright (c) The PHP Group
Zend Engine v4.0.12, Copyright (c) Zend Technologies

Es necesario habilitar y deshabilitar algunos módulos de apache para que PHP8 funcione correctamente en Manjaro:

• LoadModule mpm_event_module modules/mod_mpm_event.so (DESHABILITADO).
• LoadModule mpm_prefork_module modules/mod_mpm_prefork.so (HABILITADO).

Para ello vamos al archivo de configuración de apache:

sudo nano /etc/httpd/conf/httpd.conf

Y localizamos los dos módulos anteriores, comentando el primero y descomentando (o añadiendo si no está) el segundo.

Ahora añadimos al final del archivo las siguientes líneas:

LoadModule php_module modules/libphp.so
AddHandler php-script php
Include conf/extra/php_module.conf

Guardamos con Ctrl+O y salimos con Ctrl+X.

Reiniciamos apache para que se apliquen los cambios.

sudo systemctl restart httpd

Vamos a probar que PHP funciona correctamente. Para ello vamos a crear un archivo info.php dentro de la carpeta raíz de proyectos de Apache que en Manjaro se encuentra en la ruta /srv/http:

sudo nano /srv/http/info.php

Y dentro llamamos a la función phpinfo();

<?php
    phpinfo();
?>

Guardamos, salimos de nano y nos dirigimos al navegador web, hacia la dirección http://localhost/info.php, donde tendrá que aparecer una pantalla como esta:

Esto significa que tanto Apache como PHP están corriendo correctamente.

Ahora, para gestionar las bases de datos de forma más cómoda, vamos a instalar y configurar phpMyAdmin, que en Manjaro también requiere de algunas configuraciones adicionales.

Instalar y configurar phpMyAdmin

Instalamos el paquete desde un terminal:

sudo pacman -S phpmyadmin

Antes de ejecutarlo necesitamos hacer algunas configuraciones en el archivo php.ini situado en la ruta /etc/php/php.ini:

sudo nano /etc/php/php.ini

Y descomentamos las siguientes líneas (eliminando el # o el ; del inicio):

extension=bz2
extension=gd
extension=mysqli
extension=iconv
extension=pdo_mysql

Ya que estamos, podemos aprovechar y modificar algunos parámetros para mejorar la experiencia con WordPress o cualquier otro CMS. Los parámetros mínimos aconsejables serían:

memory_limit = 128M
post_max_size = 64M
max_execution_time = 180
upload_max_filesize = 64M
max_input_time = 180
max_input_vars = 3000

Los localizamos con Ctrl+W y los modificamos uno a uno.

Tras finalizar, guardamos con Ctrl+O y salimos con Ctrl+X.

Y reiniciamos apache ara que se aplique los cambios:

sudo systemctl restart httpd

Ahora necesitamos crear un archivo de configuración para phpMyAdmin que situaremos en la ruta:

sudo nano /etc/httpd/conf/extra/phpmyadmin.conf

Y dentro insertamos las siguientes líneas:

Alias /phpmyadmin "/usr/share/webapps/phpMyAdmin"
<Directory "/usr/share/webapps/phpMyAdmin">
DirectoryIndex index.php
AllowOverride All
Options FollowSymlinks
Require all granted
</Directory>

Guardamos y salimos.

Volvemos al archivo de configuración de Apache:

sudo nano /etc/httpd/conf/httpd.conf

Y al final del archivo añadimos la siguiente línea:

Include conf/extra/phpmyadmin.conf

Ya estaríamos listos para inciar phpMyAdmin, pero para evitar que aparezcan algunos mensajes de error, configuraremos la frase secreta del panel editando:

sudo nano /etc/webapps/phpmyadmin/config.inc.php

Y localizamos la línea:

$cfg['blowfish_secret'] = 'ESCRIBE_UNA_CLAVE_LARGA_Y_COMPLEJA'; /* YOU MUST FILL IN THIS FOR COOKIE AUTH!$ /**

Y al final del archivo añadimos:

$cfg['TempDir'] = '/tmp/phpmyadmin';

Reiniciamos Apache.

Abrimos el navegador y nos dirigimos a http://localhost/phpmyadmin, donde deberíamos ver la pantalla de login:

Por último vamos a habilitar el modulo ReWrite en Apache para que podamos habilitar las URLs amigables en WordPress (en los enlaces permanentes).

Habilitar mod_rewrite para URLs amigables en WordPress

Nos dirimos al archivo de configuración de Apache:

sudo nano /etc/httpd/conf/httpd.conf

Y localizamos la parte de código donde empieza <Directory «/srv/http»>

Un poco mas abajo modificamos la línea:

AllowOverride None por AllowOverride All

Y localizamos y descomentamos la línea:

LoadModule rewrite_module modules/mod_rewrite.so

Reiniciamos Apache y ya tendríamos listo el Stack LAMP para Manjaro y optimizado para WordPress.

Espero que este artículo te haya servido y lo compartas si ha sido así. Nos vemos en el siguiente post

Actualmente estoy probando Fedora como distro principal y tenía la necesidad de configurar mi entorno LAMP tal y como lo tenía en Ubuntu.

En Fedora la paquetería difiere un poco, así como algunas configuraciones.

En este artículo vamos a ver cómo:

• Instalar el servidor web (Apache).
• Instalar el gestor de bases de datos MariaDB.
• Instalar PHP.
• Configurar php.ini con los valores óptimos para WordPress.
• Instalar phpMyAdmin para gestionar las bases de datos visualmente.
• Activar el módulo MOD REWRITE para que funcionen las URLs «amigables» en WordPress.

Instalar el servidor web Apache

Nos dirigimos a un terminal y escribimos:

sudo dnf -y install httpd

Los comandos básicos para gestionar el servidor son:

Iniciar:

sudo systemctl start httpd

Parar:

sudo systemctl stop httpd

Habilitar:

sudo systemctl enable httpd

Reiniciar:

sudo systemctl restart httpd

Recargar:

sudo systemctl reload httpd

Una vez instalado, ejecutamos los comandos de habilitar e iniciar:

sudo systemctl enable httpd
sudo systemctl start httpd

Nos dirigimos a un navegador web y entramos en http://localhost

Deberíamos ver una pantalla como esta:

En mi caso, una vez que se habilita e inicia el servidor por primera vez, ya no es necesario hacerlo en cada sesión.

Instalar MySQL (MariaDB)

De vuelta al terminal ejecutamos:

sudo dnf install mariadb-server

Los comandos para gestionar el servicio son muy similares a Apache.

Habilitar:

sudo systemctl enable mariadb

Iniciar:

sudo systemctl start mariadb

Parar:

sudo systemctl stop mariadb

Reiniciar:

sudo systemctl restart mariadb

Al igual que con Apache, en mi caso no es necesario habilitar e iniciar el servicio en cada sesión.

Securizar MySQL

Por defecto, el gestor de bases de datos viene con el usuario root sin contraseña. Vamos a asignar una contraseña ejecutando:

sudo mysql_secure_installation

Nos preguntará si queremos asignar una contraseña al usuario root, contestamos que si:

Set root password? [Y/n] y
New password: *******
Re-enter new password: ****** 
Password updated successfully!

Nos hará una serie de preguntas sobre si queremos eliminar usuarios anónimos, borrar las tablas de test, etc. Podemos contestar afimartívamente a todo:

Remove anonymous users? [Y/n] y
 ... Success!
 
 Disallow root login remotely? [Y/n] y
 ... Success!
 
 Remove test database and access to it? [Y/n] y
 - Dropping test database...
 ... Success!
 
 - Removing privileges on test database...
 ... Success!
 
 Reload privilege tables now? [Y/n] y
 ... Success!

Ahora entraremos en mysql:

sudo mysql -u root

Vamos a crear un usuario distinto de root que será el que asignemos a las bases de datos que creemos después:

CREATE USER mi_usuario IDENTIFIED BY 'password';

Creamos una nueva base de datos:

CREATE DATABASE mibase;

Y asignamos nuestro usuario anterior a la nueva base de datos con todos los privilegios:

GRANT ALL PRIVILEGES ON mibase.* TO mi_usuario;

Para nuevas bases de datos el proceso sería el mismo: Crear la base de datos y asignar nuestro usuario con todos los privilegios.

Tras la asignación de nuestro usuario a la nueva base de datos no está de más hacer una limpieza de la caché almacenada con:

FLUSH PRIVILEGES;

Instalar PHP

Vamos a instalar los siguientes paquetes para PHP:

sudo dnf -y install php php-cli php-php-gettext php-mbstring php-mcrypt php-mysqlnd php-pear php-curl php-gd php-xml php-bcmath php-zip

Tras la instalación vamos a comprobar la versión de PHP con el comando:

php -v

En el momento de hacer este artículo, la versión que se instala con Fedora 34 es la 7.4.24.

Crearemos un archivo test.php para comprobar que PHP se ejecuta correctamente bajo Apache.

A mí me gusta usar nano para configurar archivos sencillos mediante la terminal, nos dirigimos a:

sudo nano /var/www/html/test.php

Y dentro pegamos la siguiente línea:

<?php phpinfo(); ?>

Guardamos los cambios con Ctrl+O y salimos con Ctrl+X.

Volvemos al navegador web a la dirección http://localhost/test.php

Debería ejecutarse el script de información de PHP:

Vamos a cambiar algunos parámetros de PHP editando su archivo de configuración (php.ini) para optimizarlo para WordPress.

La ubicación está en /etc/php.ini, por lo que de nuevo con nano, nos dirigimos a:

sudo nano /etc/php.ini

Y editamos los siguiente parámetros:

memory_limit = 128M
post_max_size = 64M
max_execution_time = 180
upload_max_filesize = 64M
max_input_time = 180
max_input_vars = 3000

Tras la edición debemos reiniciar Apache para que los cambios surjan efecto. En mi caso tuve que reiniciar el PC por completo para que se aplicaran.

Instalar phpMyAdmin

Volvemos al terminal y ejecutamos:

sudo dnf install phpmyadmin

Tras la instalación veremos que si accedemos a http://localhost/phpmyadmin nos saldrá un mensaje de error indicando que la ubicación no existe.

Tenemos que editar el archivo de configuración de phpMyAdmin de nuevo con nano:

sudo nano /etc/httpd/conf.d/phpMyAdmin.conf

Hacia la parte final del archivo, añadimos las siguientes líneas:

<Directory /usr/share/phpMyAdmin>
    AddDefaultCharset UTF-8
    Require all granted
</Directory>

Guardamos con Ctrl+O y salimos con Ctrl+X.

Reiniciamos el servidor con:

sudo systemctl restart httpd

O reiniciamos el equipo si no surje efecto. Ahora podemos acceder a http://localhost/phpmyadmin

Por último vamos a activar el módulo de Apache MOD REWRITE para habilitar las URLs amigables de WordPress que configuramos en los ajustes de Enlaces Permanentes.

Para ello nos dirigimos con nano a:

sudo nano /etc/httpd/conf/httpd.conf

Localizamos la línea:

<Directory "/var/www/html">

Y sustituimos AllowOverride None por AllowOverride All

De nuevo, reinicia Apache o directamente el PC.

Nota final

Si al descargar algún tema/plugin o actualización tienes un error de:

Descarga fallida: cURL error 7

Necesitamos configurar SElinux en modo permisivo. Para ello editamos el siguiente archivo:

sudo nano /etc/selinux/config

Y cambiamos el parámetro SELINUX=permissive

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#       enforcing - SELinux security policy is enforced.
#       permissive - SELinux prints warnings instead of enforcing.
#       disabled - No SELinux policy is loaded.
SELINUX=permissive
# SELINUXTYPE= can take one of these two values:
#       targeted - Targeted processes are protected,
#       mls - Multi Level Security protection.
SELINUXTYPE=targeted

Reiniciamos el equipo y eso es todo

Imagina que tienes una web en WordPress y quieres traducirla a varios idiomas. Puedes valerte de plugins como Loco Transtale para traducir cadenas de texto de tus plugins y temas.

Y puedes usar Polylang para duplicar tus páginas y entradas en los nuevos idiomas y hacer el «switch» entre ellos.

Pero, ¿y si tienes textos escritos directamente en tu plantilla? ¿Cómo traducirlos sin duplicar la web?

Aquí en donde entra PHP…

Crea una función para obtener el código de idioma del navegador

<?php
    $idioma = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
    echo $idioma;
?>

$_SERVER es una variable PHP desde la que podemos obtener bastantes datos del servidor, entre ellos el idioma del navegador que realiza las peticiones HTTP.

Si ejecutamos el código anterior y nuestro navegador está configurado en español de España, obtendremos algo como:

es-ES,en;q=0.5

Lo que nos interesa son los 2 primeros caracteres de la respuesta «es» con los que rápidamente identificamos el idioma:

• es: español
• en: inglés
• fr: francés…

<?php
    function obtenerIdioma(){
        $idioma = substr($_SERVER["HTTP_ACCEPT_LANGUAGE"],0,2);
        return $idioma;
    }
?>

La función substr() extrae el número de caracteres que indiquemos como segundo parámetro de la función, en nuestro caso, 2 caracteres.

Ahora podemos pasar el resultado a una variable para la comprobación posterior:

$idioma_usuario = obtenerIdioma();

Y hacemos la comprobación con if:

<?php
    if($idioma_usuario == "es"){
        //Ejecuto el código para español
    }
    elseif($idioma_usuario == "en"){
        //Ejecuto el código para inglés
    }
    elseif($idioma_usuario == "fr"){
        //Ejecuto el código para francés
    }
    else{
        //Ejecuto el código para el resto de idiomas
    }
?>

Con esto ya podemos adaptar nuestros textos o funciones personalizadas a todos los idiomas que necesitemos.

Para ello contamos con Composer, un avanzado gestor de paquetes y dependencias para PHP, con el cual podemos instalar de forma sencilla una completa librería PHP para nuestro proyecto y mantener todas sus dependencias al día.

Si tienes contratado un alojamiento web, es posible que desde el panel de gestión (CPanel, Plesk…) ya cuentes con un apartado dedicado a Composer, para facilitarte la instalación de librerías en tus proyectos.

Si eres de los que como yo, desarrollas tus proyectos web en modo local (localhost) para posteriormente subirlo a un hosting final, necesitarás instalar Composer en tu sistema operativo para descargar todas las librerías y dependencias correctamente.

Yo me muevo entre distribuciones basadas en Ubuntu (Debian), aunque seguramente el proceso de instalación no difiera mucho de otras basadas en Arch o Red Hat.

Instalar Composer en Ubuntu (y derivadas)

Cuando hablamos de derivadas, nos referimos a distribuciones que tienen como base Ubuntu, ya sean los sabores oficiales de Ubuntu (Ubuntu Mate, Xubuntu, Lubuntu, Kubuntu…) y otras tales como Linux Mint, KDE Neon, Zorin OS, Elementary OS…

Instalar paquetes necesarios

Antes de instalar Composer, necesitamos contar con los siguientes paquetes previamente instalados:

sudo apt update
sudo apt install wget php-cli php-zip unzip

Descarcar Composer desde el terminal

Vamos a descargar Composer directamente desde la línea de comandos:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

Con esto hemos descargado el archivo composer-setup.php en el directorio en curso del terminal.

Verificar la instalación

Para garantizar la integridad del archivo descargado utilizamos el HASH SHA-384. Primero tomamos el HASH desde la propia fuente:

HASH="$(wget -q -O - https://composer.github.io/installer.sig)"

Y lo comparamos con nuestro archivo recién descargado:

php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Si la verificación es correcta debemos ver el mensaje «Installer verified», de lo contrario nos dirá «Installer corrupt». En este último caso, tendríamos que volver a empezar el proceso desde el principio hasta que la verificación sea la correcta.

Instalar Composer de modo global

Para poder utilizar Composer desde cualquier ubicación de nuestor equipo, vamos a instalarlo en /usr/local/bin

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

Deberíamos ver algo como:

All settings correct for using Composer
Downloading...

Composer (version X.X.X) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Si todo ha ido bien, lanzamos Composer desde el terminal y deberíamos ver algo así:

Instalar librerías en nuestro proyecto usando Composer

Si decesitamos instalar una librería en nuestro proyecto web, solo tenemos que situarnos en el directorio de nuestro proyecto y ejecutar:

composer require vendor/name

Hay que sustituir vendor/name por el nombre de la librería.

Normalmente se instala un directorio /vendor en nuestro proyecto con todos los archivos y dependencias de la librería referenciada.

Para usarla solo tenemos que hacer require once en nuestro script PHP o archivo de funciones del proyecto y ya tendremos acceso a todas las funciones y métodos de la librería:

require once '/vendor/autoload.php';

Si usas Visual Studio Code, es tan sencillo como abrir un terminal en el directorio y ejecutar la orden:

Y nada más, una vez terminado el proyecto, subimos todo al hosting (incluyendo el directorio /vendor).

Un saludo y nos vemos en el siguiente post

Si queremos tener un entorno de desarrollo web en nuestro PC, podemos instalar el paquete de herramientas XAMPP, que ofrece un sencillo asistente para tener todo el ecosistema de servidor web (Apache, MySQL y PHP) en unos pocos clics.

Pero si tenemos algún problema con estos «meta-paquetes», o queremos tener un entorno más optimizado/personalizado, podemos instalar todo por separado.

En este artículo vamos a ver paso a paso los componentes a instalar y los ajustes necesarios para trabajar con WordPress.

Artículo en vídeo:

Instalar el servidor Apache

sudo apt install apache2

Comandos para Apache:

Arrancar Apache

sudo systemctl start apache2

Reiniciar Apache

sudo systemctl restart apache2

Detener Apache

sudo systemctl stop apache2

Para comprobar que Apache está iniciado, podemos ir a nuestro navegador y acceder a la url http://localhost, donde debe aparecer una pantalla similar a esta:

La carpeta donde se ubicarán nuestros proyectos es:

/var/www/html

Instalar el gestor de bases de datos MariaDB

sudo apt install mariadb-server
sudo apt install mariadb-client

Comandos para iniciar y ver el estado de MariaDB:

sudo systemctl start mariadb
sudo systemctl status mariadb

Por defecto, MariaDB se instala con el usuario root sin contraseña. Podemos crear una contraseña llamando al módulo:

sudo mysql_secure_installation

Definimos una contraseña. También nos preguntará si deseamos quitar usuarios invitados, eliminar las tablas de tests o el acceso remoto de root. Podemos especificar que sí a todo.

En este momento podemos crear nuestro usuario MySQL distinto de root. Para ello accedemos a la consola de MySQL con el comando:

sudo mysql -u root -p

Ponemos la contraseña de root y aparecerá el prompt de MySQL

Para crear nuestro usuario ejecutamos la orden:

CREATE USER tu_usuario IDENTIFIED BY 'tu_clave';

Aprovechamos también para crear la base de datos para WordPress y asignar el nuevo usuario a esta:

CREATE DATABASE wordpress;

Asignamos nuestro nuevo usuario a la base de datos wordpress con todos los privilegios:

GRANT ALL PRIVILEGES ON wordpress.* TO tu_usuario;

FLUSH PRIVILEGES;

Instalar PHP

Instalamos la versión que venga en los repositorios de nuestra distro actual. En el caso de Ubuntu 18.04, la versión de php disponible es la 7.2.

sudo apt install php8.3 php8.3-fpm php8.3-mysql php8.3-curl libapache2-mod-php libapache2-mod-php8.3

Para comprobar si PHP se ha instalado correctamente podemos crear un archivo con nano en el directorio de proyectos de Apache:

sudo nano /var/www/html/info.php

<?php echo phpinfo(); ?>

Y acceder desde el navegador a http://localhost/info.php

Debe aparecer una pantalla con la información de PHP:

Instalar phpMyAdmin

sudo apt install phpmyadmin

Durante la instalación el terminal nos hará algunas preguntas, como en qué servidor queremos configurar phpMyAdmin, donde elegiremos apache2.

También nos preguntará si queremos utilizar dbconfig-common para configurar la base de datos, respondemos que sí.

Ajustes y recomendaciones para WordPress

Ahora podemos instalar nuestros proyectos WordPress como siempre, utilizando la ruta /var/www/html, pero debemos hacer algunos ajustes para que WordPress no nos de problemas.

Activar el módulo ReWrite de Apache

Este módulo es necesario para activar los enlaces permanentes de WordPress (para que reconozca nuestros slugs).

Para activarlo ejecutamos la orden:

sudo a2enmod rewrite

Ahora editamos el archivo de configuración:

sudo nano /etc/apache2/sites-available/000-default.conf

Añadiendo al final:

<Directory "/var/www/html">
AllowOverride All
</Directory>

Y reiniciamos Apache:

sudo systemctl restart apache2

PARÁMETROS RECOMENDADOS PARA WORDPRESS EN PHP.INI

Editamos con nano el archivo php.ini modificando los siguientes parámetros:

sudo nano /etc/php/8.3/apache2/php.ini

memory_limit = 128M
post_max_size = 64M
max_execution_time = 180
upload_max_filesize = 64M
max_input_time = 180
max_input_vars = 3000

Y con esto dejamos terminado nuestro entorno de desarrollo web optimizado para trabajar en WordPress.

Si tienes dudas o algún problema, no dejes de escribirlo en los comentarios. Nos vemos en el siguiente post

Ahora lo que nos falta es crear la página archivo (archive page) para listar nuestro custom post, a modo de listado de entradas de WordPress.

Para ello, al igual que hicimos con el template para el custom post (single-vehiculos.php), necesitamos crear un nuevo archivo (page.php) al que llamaremos por ejemplo page-todos-los-vehiculos.php y guardaremos en el directorio principal del tema activo.

page.php es el archivo que contiene la estructura básica para una página interna de WordPress y al igual que hicimos con single.php, vamos a aprovechar el codigo escrito para copiarlo en nuestro archivo page-todos-los-vehiculos.php y eliminaremos lo que no necesitamos, dejando únicamente el inicio y final del loop.

Dentro del loop vamos a crear la consulta que buscará todas entradas de tipo vehículo.

La esctructura de la consulta se define:

$args = array(
    'post_type' => 'vehiculos',
    'posts_per_page' => -1,
    'orderby' => 'date',
    'order' => 'DESC'
);
$consulta_vehiculos = new WP_Query($args);

Primero declaramos una variable $args (argumentos) de tipo array donde pasamos los argumentos de la consulta. Los argumentos más básicos que vamos a definir son: el tipo de post al que hacemos referencia (vehículos), el número de resultados por página (-1 devuelve todos los resultados), el orden (por fecha) y el recorrido del orden (ascendente ASC o descendente DESC).

Existen muchos otros argumentos que ponemos incorporar a la consulta para complicarla todo lo que deseemos, pero de momento vamos a empezar por lo más básico.

Despues generamos una nueva consulta new WP_Query() pasándole los argumentos definidos anteriormente: new WP_Query($args).

A continuación vamos a mostrar los datos recogidos en la consulta creando nuestro propio loop. La síntaxis sería la siguiente:

while($consulta_vehiculos->have_posts()) : $consulta_vehiculos->the_post();
   //Código
endwhile; wp_reset_postdata();

La forma de declarar nuestro loop personalizado es muy similar al que toma WordPress para el loop principal, con la diferencia de que especificamos la variable donde tenemos nuestra consulta:

while($consulta_vehiculos->have_posts())
$consulta_vehiculos->the_post()

Lo que se traduciría en lenguaje comprensible como: «Mientras existan posts de vehículos, muestrame el post de vehículo«.

El final del loop finaliza con endwhile;

Además, para los loops personalizados añadimos la función wp_reset_postdata() para «limpiar» los datos de la consulta una vez mostrados y que no interfieran con otros loops que podamos definir en otras partes.

Para asociar este nuevo archivo con una página interna de WordPress que podamos, por ejemplo añadir al menú principal, crearemos una nueva página y utilizaremos como slug (enlace permanente) el nombre que le hayamos dado al archivo del listado, es decir si hemos llamado al archivo page-todos-los-vehiculos.php utilizaremos como slug en la nueva página «todos-los-vehiculos«.

Como siempre, actualizamos los enlaces permanentes de WordPress en Ajustes – Enlaces Permanentes – Guardar Cambios y en este momento quedará asociado el nuevo archivo page-todos-los-vehiculos.php con la página interna de WordPress Vehículos.

Para probar nuestra nueva página, vamos a incluir en loop una llamada a la función the_title(), que deberá devolvernos todos los títulos de los post de tipo vehículo que haya en la base de datos:

while($consulta_vehiculos->have_posts()) : $consulta_vehiculos->the_post();
    the_title();
endwhile; wp_reset_postdata();

Si visualizamos la página Vehículos, veremos que mostrará el título del post que hay actualmente creado de tipo vehículo:

Vamos a añadir algunos vehículos más para poder jugar con los listados de resultados:

Para la página de archivo de vehículos, tomaremos algunos datos para generar el listado, a parte del título, tomaremos la imagen destacada y una parte del contenido. Para ello, en lugar de llamar a la función the_content(), llamaremos a la función the_excerpt(), que toma solamente una parte del contenido.

while($consulta_vehiculos->have_posts()) : $consulta_vehiculos->the_post();
    the_post_thumbnail();
    the_title('<h2>','</h2>');
    the_excerpt();
endwhile; wp_reset_postdata();

Obtendríamos como resultado:

Por supuesto ya dependería de nosotros darle un poco de formato CSS, metiendo cada apartado en su correspondiente DIV, ajustando el tamaño de las miniaturas, etc. Detalles de diseño que no vamos a ver en este artículo, pues se extendería demasiado y el objetivo principal es el de generar el listado de entradas.

En siguientes artículos veremos cómo paginar este listado, para cuando tengamos un número importante de entradas.

Nos vemos en el siguiente post!

Dentro de cualquier tema WordPress, el archivo destinado a cargar la información de una entrada es el single.php.

La siguiente imagen muestra el contenido del archivo single.php del tema Twenty Sixteen de WordPress. Cada tema tendrá su código propio, pero lo que nos interesa identificar es dónde comienza y termina el loop. El loop es el código que recoge la información del post que estamos llamando y suele comenzar con:

while ( have_posts() ) : the_post();

y terminar con:

endwhile;

Todo lo que va dentro del loop suelen ser las funciones que llaman al título de la entrada, al contenido y a la sección de comentarios.

Para crear un fichero similar que cargue el contenido de nuestros custom posts, solo tenemos que crear un nuevo archivo al que llamaremos single-nombre_del_custom_post.php. En nuestro caso será single-vehiculos.php.

Para este nuevo archivo podemos aprovechar todo el contenido del single.php original (para llamar a la cabecera, sidebars, footer, y menús del tema…) y quedarnos únicamente con el loop vacío, pues añadiremos nuestro propio código para cargar el custom post de Vehículos.

Una vez creado el archivo single-vehiculos.php vamos a refrescar los enlaces permanentes de WordPress, para que este detecte que cada vez que accedamos a una URL del tipo mi-dominio.com/vehiculos/nombre-del-post, cargue la nueva plantilla en lugar de la original. Solo tenemos que ir a Ajustes de WordPress – Enlaces permanentes y Guardar cambios.

Si intentamos acceder a una entrada de tipo Vehículo, veremos que carga correctamente (la URL toma /vehiculos/ford-focus-1-8-tddi), pero el contenido está vacío. Es normal pues dentro del loop no hemos añadido nada de momento.

Para llamar al título del contenido, añadiremos la función the_title() dentro del loop:

Y como resultado obtenedremos el título de la entrada:

Lo normal es que el título tenga un tamaño destacado, para ello la función the_title() permite definir que el contenido aparezca entre etiquetas HTML, por ejemplo un H2, declarándolo de este modo:

the_title('<h2>','</h2>');

Y el resultado obtenido será:

También podríamos añadir la imagen destacada, con la función the_post_thumbnail(), declarándola a continuación del título, así como el contenido (procedente del editor de WordPress) con la función the_content():

// Start the loop.
while ( have_posts() ) :
    the_post();
    the_title('<h2>','</h2>'); //Llama al título del post
    the_post_thumbnail(); //Llama a la imagen destacada del post
    the_content(); //Llama al contenido
// End of the loop.
endwhile;

Esto nos dará como resultado:

Hay que tener en cuenta que la imagen destacada aparecerá con el tamaño del archivo original, o el que permita el contenedor (<div>) donde se encuentre. Podemos llamar a la imagen destacada con un tamaño específico siempre que este se haya declarado en el archivo de funciones del tema.

Por ejemplo, si quisiéramos que la imagen destacada apareciera en el post con un ancho de 500px, tendríamos que definirlo en el archivo de funciones (function.php) del tema activo con:

function tamano_miniaturas(){
    add_image_size('cabeceraPost', 500, false);
}
add_action('after_setup_theme', 'tamano_miniaturas');

La función add_image_size(), recibe 4 parámetros, el identificador del tamaño, la anchura, la altura y el factor de recorte de proporción (true o false). En este caso solo hemos especificado la anchura, ya que desconocemos la proporción de la imagen y de fijar un alto fijo esta podría aparecer desproporcionada.

Después tendríamos que llamar a la función the_post_thumbnail(‘cabeceraPost’), pasándole como parámetro el identificador del tamaño que hemos especificado en add_image_size().

Pero esto son temas de diseño que no vamos a abordar en este post.

Solo nos quedaría llamar a nuestros campos personalizados para mostrar el precio y matrícula del vehículo.

Advances Custom Field dispone de 2 funciones principales para extraer la información de los campos personalizados:

• the_field(‘identificador_del_campo’)
• get_field(‘identificador_del_campo’)

La principal diferencia entre ellos es que the_field() escribe directamente los datos del campo en el lugar donde lo invoquemos, (viene pre-formateado). Y get_field() está pensado para extraer el valor del campo y almacenarlo en algún lugar, por ejemplo una variable. El uso de uno u otro dependerá de nuestras necesidades. Si solo necesitamos pintar el valor del campo en un div vacío, puede que nos interese hacerlo directamente con the_field(), pero si el dato va a ir dentro de una estructura HTML más compleja, como una tabla, es posible que el pre-formateo de the_title() interfiera y no se muestre correctamente, en casos así sería mejor usar el get_field() guardando el dato en una variable y pintar la variable con un echo. Así es como lo vamos a hacer en nuestro ejemplo:

Definimos una variable $precio y le pasamos el valor del campo personalizado ‘precio’ con un get_field()

$precio = get_field('precio');

Y lo mismo con el campo matrícula:

$matricula = get_field('matricula');

Después pintamos los campos con un echo y un poco de HTML:

echo "<h3>Precio: " . $precio . "€</h3>";
echo "Matrícula: " . $matricula . "</h3>";

El resultado obtenido será:

Si necesitamos formatear el precio con separadores de miles y decimales, podemos usar la función number_format() de PHP:

echo "<h3>Precio: " . number_format($precio, 2, ',', '.') . "€</h3>";

A la función number_format() le pasamos la variable $precio, el número de decimales a mostrar, el separador de decimales ‘,’ y el separador de miles ‘.’ y tendremos como resultado:

De esta forma formateamos el precio en el momento de pintarlo en el front-end mientras que en la base de datos se mantiene en formato numérico puro, pudiendo más adelante utilizarlo para ordenar vehículos por precio.

En el siguient post veremos como crear una página archivo con los vehículos que ya tengamos guardados en la base de datos.

Las taxonomías sirven para categorizar, organizar y filtrar nuestros contenidos de una forma mucho más concisa que utilizando el simple cajetín de categorías que WordPress incorpora por defecto. De hecho, tanto las categorías como las etiquetas de WordPress son en sí taxonomías. Veremos más adelante por qué.

Continuando con el ejemplo del concesionario de vehículos, supongamos que necesitamos catalogar estos vehículos de diferentes formas. Por ejemplo, podríamos categorizarlos por tipo de vehículo: coche, camión, motocicleta…, pero también podríamos necesitar categorizarlo por el tipo de motor: diesel, gasolina, eléctrico…, por el número de puertas: 3, 4, 5…, por la marca, color, etc.

En este caso, la categoría por defecto se nos quedaría corta, de ahí que necesitemos extender el número de «categorías» para definir correctamente el vehículo. Esa es la función principal de las taxonomías.

Además, gracias a las taxonomías, podremos construir consultas personalizadas para mostrar únicamente las entradas que tengan marcadas esas taxonomías.

Para declarar una taxonomía, utilizaremos como siempre, el archivo de funciones del tema activo (functions.php) o nuestro propio plugin de funciones. Podemos declarar todas las taxonomías que necesitemos utilizando la misma función.

Declara una taxonomía

function mis_taxonomias(){
    //Tipo de Vehículo
    $labels = array(
     'name' => _x('Tipo de Vehículo', 'taxonomy general name', 'twentysixteen'),
     'singular_name' => _x('Tipo de Vehículo', 'taxonomy_general_name', 'twentysixteen'),
     'search_items' => __('Buscar Tipo de Vehículo', 'twentysixteen'),
     'all_items' => __('Todos los Tipos de Vehículos', 'twentysixteen'),
     'parent_item' => __('Padre Tipo de Vehículo', 'twentysixteen'),
     'parent_item_colon' => __('Padre Tipo de Vehículo', 'twentysixteen'),
     'edit_item' => __('Editar Tipo de Vehículo', 'twentysixteen'),
     'update_item' => __('Actualizar Tipo de Vehículo', 'twentysixteen'),
     'add_new_item' => __('Añadir Nuevo Vehículo', 'twentysixteen'),
     'new_item_name' => __('Nuevo Tipo de Vehículo', 'twentysixteen'),
     'menu_name' => __('Tipo de Vehículo', 'twentysixteen'),
    );
    $args = array(
     'hierarchical'  => true,
     'labels'  => $labels,
     'show_ui'  => true,
     'show_admin_column'     => true,
     'query_var'  => true,
     'rewrite'  => array('slug' => 'tipo_de_vehiculo'),
    );
    register_taxonomy('tipo-vehiculo', array('vehiculos'), $args);
}
add_action('init','mis_taxonomias');

La función register_taxonomy() es la encargada de declarar nuestras taxonomías personalizadas.

La declaración es bastante similar a declarar un nuevo custom post. Por un lado recibe las etiquetas (labels) para los textos que se mostrará en el panel de WordPress, y por otro los argumentos (args) que definen las caracteríticas y el comportamiento.

Los argumentos más interesantes son:

• hierarchical: su estado puede ser true o false. Si es true, la taxonomía mostrará los elementos a modo de listado para seleccionarlos tal y como se hace con las Categorías de WordPress. Si está en false, la taxonoḿia se verá como un campo de texto, donde insertaremos manualmente el nombre de los elementos de la taxonomía (como las Etiquetas de WordPress).
• rewrite: Donde especificaremos el slug de la taxonomía, que nos permitirá usar en un nuevo template para obtener un listado de las entradas que incluyan dicha taxonomía.

Una vez declarada, esta taxonomía se incluirá directamente como submenú dentro del menú de Vehículos (nuestro custom posts):

Accediendo a la taxonomía podremos añadir elementos:

Una vez creados los elementos de la taxomía, si añadimos un nuevo vehículo veremos el cajetín de la taxonomía, con su listado de elementos a modo de nueva categoría.

Aprovechando la misma funcion (mis_taxonomias()), vamos a añadir una nueva categoría pero de un estilo más «flexible», donde vamos a especificar los «extras» del vehículo: aire acondicionado, pintura metalizada, dirección asistida, navegador…). Para ello crearemos una taxonomía al estilo de Etiquetas de WordPress.

//Extras del Vehículo
    $labels = array(
     'name' => _x('Extras', 'taxonomy general name', 'twentysixteen'),
     'singular_name' => _x('Extras', 'taxonomy_general_name', 'twentysixteen'),
     'search_items' => __('Buscar Extras', 'twentysixteen'),
     'all_items' => __('Todos los Extras', 'twentysixteen'),
     'parent_item' => __('Padre Extras', 'twentysixteen'),
     'parent_item_colon' => __('Padre Extras', 'twentysixteen'),
     'edit_item' => __('Editar Extras', 'twentysixteen'),
     'update_item' => __('Actualizar Extras', 'twentysixteen'),
     'add_new_item' => __('Añadir Extras', 'twentysixteen'),
     'new_item_name' => __('Nuevo Extras', 'twentysixteen'),
     'menu_name' => __('Extras', 'twentysixteen'),
    );
    $args = array(
     'hierarchical'  => false,
     'labels'  => $labels,
     'show_ui'          => true,
     'show_admin_column'     => true,
     'query_var'  => true,
     'rewrite'  => array('slug' => 'extras'),
    );
    register_taxonomy('extras', array('vehiculos'), $args);

Para conseguir el aspecto de taxonomía a modo de etiquetas, solo tenemos que definir el parámetro ‘hierarchical’ en false.

Ahora que sabemos cómo declarar nuevas taxonomías, crearemos algunas más que usaremos para hacer pruebas.

En el siguiente post veremos cómo crear campos personalizados internos para nuestro custom post, como por ejemplo, un campo para el precio, otro para el año de fabricación, el kilometraje (si el vehículo es usado), etc.

Imaginemos que estamos desarrollando la web de un concesionario de vehículos y queremos publicarlos de forma que cada vehículo se trate como una entrada individual, y así poder categorizarlos, añadirles etiquetas, realizar búsquedas, etc.

Los custom post pueden ser declarados en el archivo de funciones del tema activo (functions.php) o en nuestro propio plugin de funciones.

Declarar un custom post

La estructura básica para añadir el nuevo custom post sería:

<?php
//Custom Post Vehículos
function post_Vehiculos(){
 $labels = array(
 'name'               => _x('Vehículos', 'twentysixteen'),
 'singular_name'      => _x('Vehículo', 'post type singular name', 'twentysixteen'),
 'menu_name'          => _x('Vehículos', 'admin menu', 'gestiona-inmobiliaria'),
 'name_admin_bar'     => _x('Vehículos', 'add new on admin bar', 'twentysixteen'),
 'add_new'            => _x('Añadir Vehículo', 'book', 'twentysixteen'),
 'add_new_item'       => __('Añadir Nuevo Vehículo', 'twentysixteen'),
 'new_item'           => __('Nuevos Vehículos', 'twentysixteen'),
 'edit_item'          => __('Editar Vehículo', 'twentysixteen'),
 'view_item'          => __('Ver Vehículo', 'twentysixteen'),
 'all_items'          => __('Todos los Vehículos', 'twentysixteen'),
 'search_items'       => __('Buscar Vehículos', 'twentysixteen'),
 'parent_item_colon'  => __('Parent Vehículos:', 'twentysixteen'),
 'not_found'          => __('No se han encontrado Vehículos', 'twentysixteen'),
 'not_found_in_trash' => __('No se han encontrado Vehículos en la papelera', 'twentysixteen')
 );
 $args = array(
     'labels'             => $labels,
     'description'        => __('Description.', 'twentysixteen'),
     'public'             => true,
     'publicly_queryable' => true,
     'show_ui'            => true,
     'show_in_menu'       => true,
     'query_var'          => true,
     'rewrite'            => array('slug' => 'vehiculos'),
     'capability_type'    => 'post',
     'has_archive'        => true,
     'hierarchical'       => false,
     'menu_position'      => 6,
     'supports'           => array('title', 'editor', 'author', 'thumbnail'),
 );
 register_post_type('vehiculos', $args);
}
add_action('init', 'post_Vehiculos');
?>

La función contiene 2 elementos principales, las etiquetas ($labels) y los argumentos ($args).

Las etiquetas hacen referencia a los textos que muestra WordPress acerca del custom post, tales como el nombre en singular, en plural, cómo se muestra en el menú, el texto para añadir uno nuevo, para editarlo, etc.

Los argumentos tratan cómo se comportará el custom post, algunos parámetros interesantes son:

• rewrite: el slug que generará nuestro custom post, ejemplo: www.tudominio.com/vehiculos/url_del_post. Es importante escoger uno apropiado de cara al SEO.
• capability_type: especifica si el custom post se va a comportar como una página interna (para información fija) o como un post (entrada). Normalmente pondremos tipo post.
• has_archive: define si el custom post va a tener su propio archivo-listado de posts.
• menu_position: Controla en qué posición del menú aparecerá el nuevo custom post, por ejemplo, antes o después de las Entradas normales. Podemos jugar con el número hasta dejarlo donde queremos.
• supports: Define los elementos que podremos utilizar dentro del custom post, por ejemplo un campo para el título, el editor de WordPress, el autor y la imagen destacada (thumbnail).

Una vez declarado estará disponible en nuestro menú:

Si añadimos un nuevo vehículo, veremos una pantalla de edición muy similar a las entradas, con su campo para el título, el editor de WordPress, la selección del autor y la imagen destacada:

Sin embargo esto podríamos enriquecerlo mucho más, añadiendo categorías, taxonomías y campos personalizados que desatarán realmente todo el potencial de los custom post y que harán que podamos realizar prácticamente cualquier tipo de web.

Veremos cómo integrarlos en siguientes posts.