Multisitio de WordPress para desarrollo local y remoto

Publicado: 2021-07-19

Es una práctica común utilizar entornos locales y remotos al desarrollar para web. En el caso de sitios únicos de WordPress, esto funciona bien. Sin embargo, las instalaciones de WordPress multisitio complican las cosas significativamente.

Al buscar una solución al problema de las instalaciones de WordPress Multisite, nos encontramos con una serie de artículos escritos por John Russel en Laubster Boy. En estos artículos, marcó una forma de resolver este problema para entornos de producción y desarrollo remoto, que se acercaba bastante a lo que queríamos. Con algunas modificaciones, logramos tener las cosas más o menos ordenadas. Sin embargo, desde entonces, ciertas actualizaciones de WordPress han roto esa solución y hemos tenido que revisar el problema.

En este artículo, le mostraré cómo resolvimos este problema utilizando varios recursos y algunos retoques.

Intención

Queremos poder albergar una instalación local del sitio y una instalación remota del sitio que se ejecutan en la misma base de datos (remota).

Problema

Las configuraciones multisitio de WordPress siempre redirigen a la instalación base, en este caso: remota. Esto dificulta trabajar en una base de código de desarrollo que refleje exactamente el sitio remoto.

Para evitar esto, es necesario ejecutar dos instalaciones que utilicen bases de datos diferentes. Esto puede generar conflictos confusos y problemas de sincronización, ya que con cada edición, tanto el código como las bases de datos deben fusionarse.

Solución

Utilizaremos el complemento WPMU Domain Mapping.

Tenga en cuenta que un par de archivos de este complemento se editarán directamente, por lo que es importante recordar esto si actualiza el complemento por cualquier motivo.

Este proceso asume que tiene una instalación multisitio de WordPress en sus entornos remotos y locales.

Los siguientes pasos para cada uno estarán separados por local y remoto, ya que es importante tener diferentes versiones de los mismos archivos en cada ubicación.

Entonces, con la configuración de fondo hecha, ¡sigamos con los pasos!

Estructura de directorio para multisitio de WordPress local y remoto

Como referencia, la estructura de archivos para esta configuración, tanto en entornos locales como remotos, será la siguiente:

 + - wp-config.php
|
+ - .htaccess
|
+ - contenido de wp
| |
| + - amanecer.php
| |
| + - complementos
| |
| + - mapeo-dominio-mu-wordpress
| |
| + - Changelog.txt
| |
| + - mapeo_dominio.php
| |
| + - readme.txt
| |
| + - amanecer.php
| |
| + - wordpress-mu-domain-mapping.php

1. Remoto

Esta sección brinda detalles de los archivos y configuraciones remotos.

1.1 wp-config.php

Esto no debe cambiarse en el servidor remoto.

1.2 Asignación de dominios MU de WordPress (¡remoto!)

Descargue el complemento WordPress MU Domain Mapping desde aquí:

https://en-gb.wordpress.org/plugins/wordpress-mu-domain-mapping/

Instalar en un sitio remoto y "activar la red" para que esté activo en todos los sitios.

1.3 amanecer.php

Copie el archivo sunrise.php del complemento wordpress-mu-domain-mapping directamente en el directorio wp-content , de modo que se encuentre aquí:

/wp-content/sunrise.php

1.4 Finalizar ediciones remotas

Ahora ha terminado con la edición del sitio remoto. Visite algunas páginas para asegurarse de que no se rompió nada, y terminamos aquí.

2. Local

Esta sección muestra lo que se debe hacer en localhost. Parte del código está duplicado, pero todo se muestra para completar.

2.1 wp-config.php

Copie el código de abajo y péguelo en su archivo wp-config.php. Luego puede actualizarlo con los detalles de su wp-config.php remoto (base de datos, etc.)

Necesitará actualizar esto con los detalles de su base de datos, etc., pero vamos a terminar con un documento similar al que se muestra a continuación en el " Listado de código 1: wp-config.php ".

Listado de código 1: wp-config.php



<? php


define ('MEDIO AMBIENTE', 'desarrollo');

define ('WP_DEBUG_LOG', verdadero);

define ('WP_DEBUG_DISPLAY', verdadero);

define ('WP_DEBUG', verdadero);


/ * Configuración de MySQL * /


/ ** El nombre de la base de datos para WordPress * /

define ('DB_NAME', 'mysite_db');


/ ** Nombre de usuario de la base de datos MySQL * /

define ('DB_USER', 'mysite_user');
		




/ ** Contraseña de la base de datos MySQL * /

define ('DB_PASSWORD', '***********');


/ ** Nombre de host MySQL * /

define ('DB_HOST', 'ejemplo.com');


/ ** Conjunto de caracteres de base de datos para usar en la creación de tablas de base de datos. * /

define ('DB_CHARSET', 'utf8');


/ ** El tipo de clasificación de la base de datos. No cambie esto si tiene dudas. * /

define ('DB_COLLATE', ”);


define ('AUTH_KEY', '***********');

define ('SECURE_AUTH_KEY', '***********');

define ('LOGGED_IN_KEY', '***********');

define ('NONCE_KEY', '***********');

define ('AUTH_SALT', '***********');

define ('SECURE_AUTH_SALT', '***********');

define ('LOGGED_IN_SALT', '***********');

define ('NONCE_SALT', '***********');
		




$ table_prefix = 'wp_';


/ * Multisitio * /

define ('WP_ALLOW_MULTISITE', verdadero);

define ('MULTISITE', verdadero);

define ('SUBDOMAIN_INSTALL', falso);

define ('DOMAIN_CURRENT_SITE', 'ejemplo.com');

define ('PATH_CURRENT_SITE', '/');

define ('SITE_ID_CURRENT_SITE', 1);

define ('BLOG_ID_CURRENT_SITE', 1);


define ('ADMIN_COOKIE_PATH', '/');

define ('COOKIEPATH', ”);

define ('SITECOOKIEPATH', ”);


// Cosas de la base de datos compartida de WPMU

define ('SUNRISE', 'on');

define ('WP_PRODUCTION_DOMAIN', 'ejemplo.com');

define ('WP_DEVELOPMENT_DOMAIN', 'mysite-local-domain');
		




/ * Eso es todo, ¡deja de editar! Feliz blogueo. * /


/ ** Ruta absoluta al directorio de WordPress. * /

if (! defined ('ABSPATH')) {

define ('ABSPATH', dirname (__FILE__). '/');

}


/ ** Configura las variables de WordPress y los archivos incluidos. * /

require_once (ABSPATH. 'wp-settings.php');

2.2 Asignación de dominios MU de WordPress (¡local!)

Agregue el mismo complemento al sitio local. Podrías pensar que eso es todo, según el sitio remoto, ¡pero estarías equivocado!

Abra el archivo domain_mapping.php en su editor favorito y edite las líneas 708 y 709 para que toda la declaración if se vea así:

Listado de código 2: domain_mapping.php



if ($ url && $ url! = untrailingslashit ($ protocolo. $ current_blog-> dominio. $ current_blog-> ruta)) {

$ redirect = get_site_option ('dm_301_redirect')? '301': '302';

if ((definido ('VHOST') && constante (“VHOST”)! = 'sí') || (definido ('SUBDOMAIN_INSTALL') && constante ('SUBDOMAIN_INSTALL') == falso)) {

$ _SERVER ['REQUEST_URI'] = str_replace ($ current_blog-> ruta, '/', $ _SERVER ['REQUEST_URI']);

}

// encabezado (“Ubicación: {$ url} {$ _ SERVER ['REQUEST_URI']}”, verdadero, $ redireccionamiento);

// Salida;

}

2.3 amanecer.php

Primero, copie el archivo sunrise.php del complemento wordpress-mu-domain-mapping al directorio wp-content. Puede que ya haya un archivo sunrise.php aquí. No se preocupe, simplemente sobrescríbalo.

Copiar desde aquí:

/wp-content/plugins/wordpress-mu-domain-mapping/sunrise.php

Hacia aqui:

/wp-content/sunrise.php

A continuación, edite este nuevo archivo sunrise.php, agregando líneas alrededor de la línea 40, para que se vea como el siguiente código:

Listado de código 3: sunrise.php



<? php if (! defined ('SALIDA_CARGADO')) {define ('SALIDA_CARGADO', 1); } if (defined ('COOKIE_DOMAIN')) {die ('La constante "COOKIE_DOMAIN" está definida (probablemente en wp-config.php). Por favor, elimine o comente esa línea define ().'); } $ wpdb-> dmtable = $ wpdb-> base_prefix. 'mapeo_dominio';

$ dm_domain = $ _SERVER ['HTTP_HOST'];


if (($ nowww = preg_replace ('| ^ www. |', ”, $ dm_domain))! = $ dm_domain) {

$ donde = $ wpdb-> prepare ('dominio IN (% s,% s)', $ dm_domain, $ nowww);

} demás {

$ donde = $ wpdb-> prepare ('dominio =% s', $ dm_domain);

}


$ wpdb-> suppress_errors ();

$ domain_mapping_id = $ wpdb-> get_var (“SELECCIONE blog_id FROM {$ wpdb-> dmtable} DONDE {$ where} ORDER BY CHAR_LENGTH (dominio) DESC LIMIT 1”);

$ wpdb-> suppress_errors (falso);

if ($ domain_mapping_id) {

$ current_blog = $ wpdb-> get_row (“SELECCIONAR * DESDE {$ wpdb-> blogs} DONDE blog_id = '$ domain_mapping_id' LIMIT 1”);

$ actual_blog-> dominio = $ dm_domain;

$ blog_actual-> ruta = '/';

$ blog_id = $ domain_mapping_id;

$ site_id = $ current_blog-> site_id;


define ('COOKIE_DOMAIN', $ dm_domain);


$ sitio_actual = $ wpdb-> get_row ("SELECCIONAR * de {$ wpdb-> sitio} DONDE id = '{$ blog_actual-> id_sitio}' LÍMITE 0,1”);

$ sitio_actual-> id_blog = $ wpdb-> get_var (“SELECCIONAR id_blog DE {$ wpdb-> blogs} DONDE dominio = '{$ sitio_actual-> dominio}' Y ruta = '{$ sitio_actual-> ruta}'”);

if (function_exists ('get_site_option')) {

$ sitio_actual-> nombre_sitio = get_site_option ('nombre_sitio');

} elseif (function_exists ('get_current_site_name')) {

$ current_site = get_current_site_name ($ current_site);

}


define ('DOMINIO_MAPPING', 1);

}


/ *

* 1) CÓDIGO MULITISITO AÑADIDO

* /


// Filtra el dominio que se muestra / genera en HTML

add_filter ('pre_option_home', 'dev_pre_url_filter', 1);

add_filter ('pre_option_siteurl', 'dev_pre_url_filter', 1);

add_filter ('el_contenido', 'dev_content_filter', 100);

add_filter ('content_url', 'dev_content_url_filter', 100, 2);

add_filter ('post_thumbnail_html', 'dev_content_filter', 100);

add_filter ('wp_get_attachment_link', 'dev_content_filter', 100);

add_filter ('wp_get_attachment_url', 'dev_content_filter', 100);

add_filter ('upload_dir', 'dev_upload_dir_filter', 10);


function dev_pre_url_filter () {

global $ wpdb, $ ruta, $ conmutada;

$ url;

$ ruta_conmutada;

$ blog_id = get_current_blog_id ();


if (! $ cambiado) {

$ url = is_ssl ()? 'https: //': 'http: //';

$ url. = WP_DEVELOPMENT_DOMAIN;

if (! is_main_site ()) {

$ url. = rtrim ($ ruta, '/');

}


return $ url;

} demás {

$ Switched_path = $ wpdb-> get_var (“SELECCIONE la ruta DESDE {$ wpdb-> blogs} DONDE blog_id = {$ blog_id} ORDEN POR CHAR_LENGTH (ruta) DESC LIMIT 1”);

$ url = is_ssl ()? 'https: //': 'http: //';

$ url. = WP_DEVELOPMENT_DOMAIN;

$ url. = rtrim ($ ruta_conmutada, '/');


return $ url;

}

}


function dev_content_filter ($ post_content) {

global $ wpdb;


$ blog_details = get_blog_details ();

$ original_url = $ wpdb-> get_var (“SELECCIONAR dominio DESDE {$ wpdb-> dmtable} DONDE blog_id = {$ blog_details-> blog_id} ORDENAR POR CHAR_LENGTH (dominio) DESC LIMIT 1”);

$ dev_url = WP_DEVELOPMENT_DOMAIN. $ blog_details-> ruta;


if ($ original_url! == null) {

$ post_content = str_replace ($ original_url. '/', $ original_url, $ post_content);

$ post_content = str_replace ($ original_url, $ dev_url, $ post_content);

}

// Cambie todas las URL para que apunten a la puesta en escena (imágenes, anclas, cualquier cosa dentro del contenido de la publicación)

$ post_content = str_replace (WP_PRODUCTION_DOMAIN, WP_DEVELOPMENT_DOMAIN, $ post_content);

// Cambie las URL de "subidas" para que apunten a producción para que las imágenes sean visibles

$ post_content = str_replace (WP_DEVELOPMENT_DOMAIN. $ blog_details-> ruta. 'wp-content / uploads', WP_PRODUCTION_DOMAIN. $ blog_details-> ruta. 'wp-content / uploads', $ post_content);


return $ post_content;

}


/ *

* Filtra la función content_url - buscando específicamente las llamadas content_url ('upload') donde la ruta tiene cargas en la cadena

*

* Agregado para que MU-Plugins pueda usar content_url en DEV y PROD

* /

function dev_content_url_filter ($ url, $ ruta) {

if (! empty ($ path) && strpos ($ path, 'uploads')! == false) {

return str_replace (WP_DEVELOPMENT_DOMAIN, WP_PRODUCTION_DOMAIN, $ url);

}


return $ url;

}


function dev_upload_dir_filter ($ param) {

$ param ['url'] = str_replace (WP_DEVELOPMENT_DOMAIN, WP_PRODUCTION_DOMAIN, $ param ['url']);

$ param ['baseurl'] = str_replace (WP_DEVELOPMENT_DOMAIN, WP_PRODUCTION_DOMAIN, $ param ['baseurl']);


return $ param;

}


/ *

* Reemplazo para /wp-includes/ms-load.php get_site_by_path

* /

function dev_get_site_by_path ($ _site, $ _domain, $ _path, $ _segments, $ _paths) {

global $ wpdb, $ ruta;


// Para que haya una posible coincidencia en la base de datos, configure $ _domain como WP_PRODUCTION_DOMAIN

$ _domain = WP_PRODUCTION_DOMAIN;


// Busque un sitio que coincida con el dominio y el primer segmento de ruta

$ sitio = $ wpdb-> get_row ($ wpdb-> prepare (“SELECCIONAR * DESDE $ wpdb-> blogs DONDE dominio =% sy ruta =% s”, $ _dominio, $ _rutas [0]));

$ ruta_actual = $ _rutas [0];


if ($ sitio === nulo) {

// Específicamente para el blog principal: si no se encuentra un sitio, cargue el blog principal

$ sitio = $ wpdb-> get_row ($ wpdb-> prepare (“SELECCIONAR * DESDE $ wpdb-> blogs DONDE dominio =% sy ruta =% s”, $ _dominio, '/'));

$ ruta_actual = '/';

}


// Establecer ruta para que coincida con el primer segmento

$ ruta = $ ruta_actual;


return $ sitio;

}


add_filter ('pre_get_site_by_path', 'dev_get_site_by_path', 1, 5);

3. .htaccess (local)

Inserte lo siguiente en su archivo .htaccess (tenga en cuenta que el directorio local se ha eliminado de la línea final de index.php RewriteRule):

Listado de código 4: .htaccess



# COMIENZO WordPress

<IfModule mod_rewrite.c>;

RewriteEngine On

RewriteBase /

RewriteRule ^ index.php $ - [L]


# agregue una barra al final a / wp-admin

RewriteRule ^ wp-admin $ wp-admin / [R = 301, L]


RewriteCond% {REQUEST_FILENAME} -f [OR]

RewriteCond% {REQUEST_FILENAME} -d

RewriteRule ^ - [L]

RewriteRule ^ (wp- (contenido | administración | incluye). *) $ 1 [L]

RewriteRule ^ (. *. Php) $ $ 1 [L]

RewriteRule. /index.php [L]

</IfModule>;


# FIN WordPress

4. Anfitriones virtuales

Configure los hosts virtuales para que pueda escribir el valor dado en wp-config.php (arriba) para WP_DEVELOPMENT_DOMAIN en la barra de direcciones del navegador y acceder al sitio. Normalmente, escribiría localhost, pero esto lo anulará.

En el código de ejemplo (arriba), el host virtual se configuró para tomar "price-buckland" en la barra de direcciones y dirigirse al directorio que contiene WordPress.

El proceso para agregar hosts virtuales en un entorno MAMP es el siguiente:

1) En terminal:

 $ sudo vi / etc / hosts

2) Agregue la siguiente línea, reemplazando según corresponda por la dirección que desea escribir en su navegador:

 127.0.0.1 mysite-local-domain

3) A continuación, queremos activar los hosts virtuales para su entorno local, así que abra el siguiente archivo para editarlo:

 $ sudo vi /Applications/MAMP/conf/apache/httpd.conf

Encuentra estas líneas:

 # Hosts virtuales
# Incluir /Applications/MAMP/conf/apache/extra/httpd-vhosts.conf

Y descomente la línea "Incluir", así:

 # Hosts virtuales
Incluya /Applications/MAMP/conf/apache/extra/httpd-vhosts.conf

4) Ahora edite el siguiente archivo:

 $ sudo vi /Applications/MAMP/conf/apache/extra/httpd-vhosts.conf

Y agregue dos entradas: en primer lugar, para permitir 'localhost' en su navegador y, en segundo lugar, para agregar el nuevo host virtual, lo que le permite escribir un dominio personalizado en su navegador y llegar a su servidor local:

 DocumentRoot "/ Users / username / htdocs /"
    ServerName localhost


    DocumentRoot "/ Users / username / htdocs / mysite-local-directory"
    Nombre del servidor mysite-local-domain

5) Reinicie el servidor apache. En mi caso, MAMP, pero desde la línea de comando ejecuta:

 reinicio de apachectl

Si todo salió bien, ahora debería tener una configuración funcional que le permita codificar una instalación de WordPress alojada localmente, que use una base de datos remota.

También debería poder enviar sus cambios al servidor remoto y ver una copia exacta en el sitio remoto.

¡Solución de problemas, advertencias y trucos!

Desafortunadamente, muchas (muchas) cosas pueden salir mal. Aquí hay algunos síntomas y cosas que puede probar:

    1. Las páginas de administración están bien, ¡pero no puedo visitar ninguna página de inicio interna!
    2. .htaccess falta o no se ha inicializado. Agregue el archivo y vuelva a guardar sus enlaces permanentes.
    3. ¡Más muy pronto!

Cuando trabaje en su sitio local, si va a:

 Mis sitios> Administrador de red> Panel de control

Lo llevará al sitio remoto, es decir:

 example.com/wp-admin/network

Puede que esto no sea lo que desea, pero puede escribir directamente en la barra de direcciones y permanecer en el entorno local, es decir:

mysite-local / wp-admin / network

Conclusión

Si todo salió bien, ahora debería tener una configuración funcional que le permita codificar una instalación de WordPress alojada localmente, que use una base de datos remota.

También debería poder enviar sus cambios al servidor remoto y ver una copia exacta en el sitio remoto.

¡Háganos saber cómo le ha ido siguiendo esta guía paso a paso para WordPress multisitio para desarrollo local y remoto en los comentarios a continuación!

Si necesita ayuda con su desarrollo web, no dude en contactarnos.